| 1 | /* ***** BEGIN LICENSE BLOCK ***** | |
| 2 | * | |
| 3 | * The Original Code is JTransforms. | |
| 4 | * | |
| 5 | * The Initial Developer of the Original Code is | |
| 6 | * Piotr Wendykier, Emory University. | |
| 7 | * Portions created by the Initial Developer are Copyright (C) 2007-2009 | |
| 8 | * the Initial Developer. All Rights Reserved. | |
| 9 | * | |
| 10 | * Modified by Mike Anderson for Vectorz | |
| 11 | * Distributed under terms of the GNU LGPL version 3.0 | |
| 12 | * | |
| 13 | * ***** END LICENSE BLOCK ***** */ | |
| 14 | ||
| 15 | package mikera.matrixx.algo; | |
| 16 | ||
| 17 | /** | |
| 18 | * Computes 1D Discrete Fourier Transform (DFT) of complex and real, double | |
| 19 | * precision data. The size of the data can be an arbitrary number. This is a | |
| 20 | * parallel implementation of split-radix and mixed-radix algorithms optimized | |
| 21 | * for SMP systems. <br> | |
| 22 | * <br> | |
| 23 | * This code is derived from General Purpose FFT Package written by Takuya Ooura | |
| 24 | * (http://www.kurims.kyoto-u.ac.jp/~ooura/fft.html) and from JFFTPack written | |
| 25 | * by Baoshe Zhang (http://jfftpack.sourceforge.net/) | |
| 26 | * | |
| 27 | * @author Piotr Wendykier (piotr.wendykier@gmail.com) | |
| 28 | * | |
| 29 | */ | |
| 30 | public class FFT { | |
| 31 | ||
| 32 | private static enum Plans { | |
| 33 | SPLIT_RADIX, MIXED_RADIX, BLUESTEIN | |
| 34 | } | |
| 35 | ||
| 36 | private int n; | |
| 37 | ||
| 38 | private int nBluestein; | |
| 39 | ||
| 40 | private int[] ip; | |
| 41 | ||
| 42 | private double[] w; | |
| 43 | ||
| 44 | private int nw; | |
| 45 | ||
| 46 | private int nc; | |
| 47 | ||
| 48 | private double[] wtable; | |
| 49 | ||
| 50 | private double[] wtable_r; | |
| 51 | ||
| 52 | private double[] bk1; | |
| 53 | ||
| 54 | private double[] bk2; | |
| 55 | ||
| 56 | private Plans plan; | |
| 57 | ||
| 58 | private static final int[] factors = { 4, 2, 3, 5 }; | |
| 59 | ||
| 60 | private static final double PI = 3.14159265358979311599796346854418516; | |
| 61 | ||
| 62 | private static final double TWO_PI = 6.28318530717958623199592693708837032; | |
| 63 | ||
| 64 | /** | |
| 65 | * Returns the closest power-of-two number greater than or equal to x. | |
| 66 | * | |
| 67 | * @param x | |
| 68 | * @return the closest power-of-two number greater than or equal to x | |
| 69 | */ | |
| 70 | public static int nextPow2(int x) { | |
| 71 |
2
1. nextPow2 : changed conditional boundary → NO_COVERAGE 2. nextPow2 : negated conditional → NO_COVERAGE |
if (x < 1) |
| 72 | throw new IllegalArgumentException("x must be greater or equal 1"); | |
| 73 |
3
1. nextPow2 : Replaced integer subtraction with addition → NO_COVERAGE 2. nextPow2 : Replaced bitwise AND with OR → NO_COVERAGE 3. nextPow2 : negated conditional → NO_COVERAGE |
if ((x & (x - 1)) == 0) { |
| 74 |
1
1. nextPow2 : replaced int return with 0 for mikera/matrixx/algo/FFT::nextPow2 → NO_COVERAGE |
return x; // x is already a power-of-two number |
| 75 | } | |
| 76 |
2
1. nextPow2 : Replaced Unsigned Shift Right with Shift Left → NO_COVERAGE 2. nextPow2 : Replaced bitwise OR with AND → NO_COVERAGE |
x |= (x >>> 1); |
| 77 |
2
1. nextPow2 : Replaced Unsigned Shift Right with Shift Left → NO_COVERAGE 2. nextPow2 : Replaced bitwise OR with AND → NO_COVERAGE |
x |= (x >>> 2); |
| 78 |
2
1. nextPow2 : Replaced Unsigned Shift Right with Shift Left → NO_COVERAGE 2. nextPow2 : Replaced bitwise OR with AND → NO_COVERAGE |
x |= (x >>> 4); |
| 79 |
2
1. nextPow2 : Replaced Unsigned Shift Right with Shift Left → NO_COVERAGE 2. nextPow2 : Replaced bitwise OR with AND → NO_COVERAGE |
x |= (x >>> 8); |
| 80 |
2
1. nextPow2 : Replaced Unsigned Shift Right with Shift Left → NO_COVERAGE 2. nextPow2 : Replaced bitwise OR with AND → NO_COVERAGE |
x |= (x >>> 16); |
| 81 |
2
1. nextPow2 : Replaced integer addition with subtraction → NO_COVERAGE 2. nextPow2 : replaced int return with 0 for mikera/matrixx/algo/FFT::nextPow2 → NO_COVERAGE |
return x + 1; |
| 82 | } | |
| 83 | ||
| 84 | /** | |
| 85 | * Returns the closest power-of-two number less than or equal to x. | |
| 86 | * | |
| 87 | * @param x | |
| 88 | * @return the closest power-of-two number less then or equal to x | |
| 89 | */ | |
| 90 | public static int prevPow2(int x) { | |
| 91 |
2
1. prevPow2 : changed conditional boundary → NO_COVERAGE 2. prevPow2 : negated conditional → NO_COVERAGE |
if (x < 1) |
| 92 | throw new IllegalArgumentException("x must be greater or equal 1"); | |
| 93 |
2
1. prevPow2 : Replaced double division with multiplication → NO_COVERAGE 2. prevPow2 : replaced int return with 0 for mikera/matrixx/algo/FFT::prevPow2 → NO_COVERAGE |
return (int) Math.pow(2, Math.floor(Math.log(x) / Math.log(2))); |
| 94 | } | |
| 95 | ||
| 96 | /** | |
| 97 | * Checks if x is a power-of-two number. | |
| 98 | * | |
| 99 | * @param x | |
| 100 | * @return true if x is a power-of-two number | |
| 101 | */ | |
| 102 | public static boolean isPowerOf2(int x) { | |
| 103 |
2
1. isPowerOf2 : changed conditional boundary → SURVIVED 2. isPowerOf2 : negated conditional → SURVIVED |
if (x <= 0) |
| 104 |
1
1. isPowerOf2 : replaced boolean return with true for mikera/matrixx/algo/FFT::isPowerOf2 → NO_COVERAGE |
return false; |
| 105 | else | |
| 106 |
4
1. isPowerOf2 : Replaced bitwise AND with OR → SURVIVED 2. isPowerOf2 : Replaced integer subtraction with addition → KILLED 3. isPowerOf2 : negated conditional → KILLED 4. isPowerOf2 : replaced boolean return with true for mikera/matrixx/algo/FFT::isPowerOf2 → KILLED |
return (x & (x - 1)) == 0; |
| 107 | } | |
| 108 | | |
| 109 | /** | |
| 110 | * Creates new instance of DoubleFFT_1D. | |
| 111 | * | |
| 112 | * @param n | |
| 113 | * size of data | |
| 114 | */ | |
| 115 | public FFT(int n) { | |
| 116 |
2
1. <init> : changed conditional boundary → KILLED 2. <init> : negated conditional → KILLED |
if (n < 1) { |
| 117 | throw new IllegalArgumentException("n must be greater than 0"); | |
| 118 | } | |
| 119 | this.n = n; | |
| 120 | ||
| 121 |
1
1. <init> : negated conditional → KILLED |
if (!isPowerOf2(n)) { |
| 122 |
2
1. <init> : changed conditional boundary → SURVIVED 2. <init> : negated conditional → SURVIVED |
if (getReminder(n, factors) >= 211) { |
| 123 | plan = Plans.BLUESTEIN; | |
| 124 |
2
1. <init> : Replaced integer multiplication with division → NO_COVERAGE 2. <init> : Replaced integer subtraction with addition → NO_COVERAGE |
nBluestein = nextPow2(n * 2 - 1); |
| 125 |
1
1. <init> : Replaced integer multiplication with division → NO_COVERAGE |
bk1 = new double[2 * nBluestein]; |
| 126 |
1
1. <init> : Replaced integer multiplication with division → NO_COVERAGE |
bk2 = new double[2 * nBluestein]; |
| 127 |
6
1. <init> : Replaced double addition with subtraction → NO_COVERAGE 2. <init> : Replaced double division with multiplication → NO_COVERAGE 3. <init> : Replaced integer division with multiplication → NO_COVERAGE 4. <init> : Replaced Shift Left with Shift Right → NO_COVERAGE 5. <init> : Replaced integer addition with subtraction → NO_COVERAGE 6. <init> : Replaced integer addition with subtraction → NO_COVERAGE |
this.ip = new int[2 + (int) Math.ceil(2 + (1 << (int) (Math.log(nBluestein + 0.5) / Math.log(2)) / 2))]; |
| 128 | this.w = new double[nBluestein]; | |
| 129 |
1
1. <init> : Replaced integer multiplication with division → NO_COVERAGE |
int twon = 2 * nBluestein; |
| 130 | nw = ip[0]; | |
| 131 |
3
1. <init> : changed conditional boundary → NO_COVERAGE 2. <init> : Replaced Shift Left with Shift Right → NO_COVERAGE 3. <init> : negated conditional → NO_COVERAGE |
if (twon > (nw << 2)) { |
| 132 |
1
1. <init> : Replaced Shift Right with Shift Left → NO_COVERAGE |
nw = twon >> 2; |
| 133 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::makewt → NO_COVERAGE |
makewt(nw); |
| 134 | } | |
| 135 | nc = ip[1]; | |
| 136 |
3
1. <init> : changed conditional boundary → NO_COVERAGE 2. <init> : Replaced Shift Left with Shift Right → NO_COVERAGE 3. <init> : negated conditional → NO_COVERAGE |
if (nBluestein > (nc << 2)) { |
| 137 |
1
1. <init> : Replaced Shift Right with Shift Left → NO_COVERAGE |
nc = nBluestein >> 2; |
| 138 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::makect → NO_COVERAGE |
makect(nc, w, nw); |
| 139 | } | |
| 140 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::bluesteini → NO_COVERAGE |
bluesteini(); |
| 141 | } else { | |
| 142 | plan = Plans.MIXED_RADIX; | |
| 143 |
2
1. <init> : Replaced integer multiplication with division → SURVIVED 2. <init> : Replaced integer addition with subtraction → KILLED |
wtable = new double[4 * n + 15]; |
| 144 |
2
1. <init> : Replaced integer multiplication with division → SURVIVED 2. <init> : Replaced integer addition with subtraction → KILLED |
wtable_r = new double[2 * n + 15]; |
| 145 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::cffti → KILLED |
cffti(); |
| 146 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::rffti → KILLED |
rffti(); |
| 147 | } | |
| 148 | } else { | |
| 149 | plan = Plans.SPLIT_RADIX; | |
| 150 |
6
1. <init> : Replaced double addition with subtraction → SURVIVED 2. <init> : Replaced double division with multiplication → SURVIVED 3. <init> : Replaced integer division with multiplication → SURVIVED 4. <init> : Replaced Shift Left with Shift Right → SURVIVED 5. <init> : Replaced integer addition with subtraction → SURVIVED 6. <init> : Replaced integer addition with subtraction → KILLED |
this.ip = new int[2 + (int) Math.ceil(2 + (1 << (int) (Math.log(n + 0.5) / Math.log(2)) / 2))]; |
| 151 | this.w = new double[n]; | |
| 152 |
1
1. <init> : Replaced integer multiplication with division → SURVIVED |
int twon = 2 * n; |
| 153 | nw = ip[0]; | |
| 154 |
3
1. <init> : changed conditional boundary → SURVIVED 2. <init> : Replaced Shift Left with Shift Right → SURVIVED 3. <init> : negated conditional → SURVIVED |
if (twon > (nw << 2)) { |
| 155 |
1
1. <init> : Replaced Shift Right with Shift Left → KILLED |
nw = twon >> 2; |
| 156 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::makewt → SURVIVED |
makewt(nw); |
| 157 | } | |
| 158 | nc = ip[1]; | |
| 159 |
3
1. <init> : changed conditional boundary → SURVIVED 2. <init> : Replaced Shift Left with Shift Right → SURVIVED 3. <init> : negated conditional → SURVIVED |
if (n > (nc << 2)) { |
| 160 |
1
1. <init> : Replaced Shift Right with Shift Left → NO_COVERAGE |
nc = n >> 2; |
| 161 |
1
1. <init> : removed call to mikera/matrixx/algo/FFT::makect → NO_COVERAGE |
makect(nc, w, nw); |
| 162 | } | |
| 163 | } | |
| 164 | } | |
| 165 | ||
| 166 | /** | |
| 167 | * Computes 1D forward DFT of complex data leaving the result in | |
| 168 | * <code>a</code>. Complex number is stored as two double values in | |
| 169 | * sequence: the real and imaginary part, i.e. the size of the input array | |
| 170 | * must be greater or equal 2*n. The physical layout of the input data has | |
| 171 | * to be as follows:<br> | |
| 172 | * | |
| 173 | * <pre> | |
| 174 | * a[2*k] = Re[k], | |
| 175 | * a[2*k+1] = Im[k], 0<=k<n | |
| 176 | * </pre> | |
| 177 | * | |
| 178 | * @param a | |
| 179 | * data to transform | |
| 180 | */ | |
| 181 | public void complexForward(double[] a) { | |
| 182 |
1
1. complexForward : removed call to mikera/matrixx/algo/FFT::complexForward → NO_COVERAGE |
complexForward(a, 0); |
| 183 | } | |
| 184 | ||
| 185 | /** | |
| 186 | * Computes 1D forward DFT of complex data leaving the result in | |
| 187 | * <code>a</code>. Complex number is stored as two double values in | |
| 188 | * sequence: the real and imaginary part, i.e. the size of the input array | |
| 189 | * must be greater or equal 2*n. The physical layout of the input data has | |
| 190 | * to be as follows:<br> | |
| 191 | * | |
| 192 | * <pre> | |
| 193 | * a[offa+2*k] = Re[k], | |
| 194 | * a[offa+2*k+1] = Im[k], 0<=k<n | |
| 195 | * </pre> | |
| 196 | * | |
| 197 | * @param a | |
| 198 | * data to transform | |
| 199 | * @param offa | |
| 200 | * index of the first element in array <code>a</code> | |
| 201 | */ | |
| 202 | public void complexForward(double[] a, int offa) { | |
| 203 |
1
1. complexForward : negated conditional → NO_COVERAGE |
if (n == 1) |
| 204 | return; | |
| 205 | switch (plan) { | |
| 206 | case SPLIT_RADIX: | |
| 207 |
2
1. complexForward : Replaced integer multiplication with division → NO_COVERAGE 2. complexForward : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * n, a, offa, ip, nw, w); |
| 208 | break; | |
| 209 | case MIXED_RADIX: | |
| 210 |
1
1. complexForward : removed call to mikera/matrixx/algo/FFT::cfftf → NO_COVERAGE |
cfftf(a, offa, -1); |
| 211 | break; | |
| 212 | case BLUESTEIN: | |
| 213 |
1
1. complexForward : removed call to mikera/matrixx/algo/FFT::bluestein_complex → NO_COVERAGE |
bluestein_complex(a, offa, -1); |
| 214 | break; | |
| 215 | } | |
| 216 | } | |
| 217 | ||
| 218 | /** | |
| 219 | * Computes 1D inverse DFT of complex data leaving the result in | |
| 220 | * <code>a</code>. Complex number is stored as two double values in | |
| 221 | * sequence: the real and imaginary part, i.e. the size of the input array | |
| 222 | * must be greater or equal 2*n. The physical layout of the input data has | |
| 223 | * to be as follows:<br> | |
| 224 | * | |
| 225 | * <pre> | |
| 226 | * a[2*k] = Re[k], | |
| 227 | * a[2*k+1] = Im[k], 0<=k<n | |
| 228 | * </pre> | |
| 229 | * | |
| 230 | * @param a | |
| 231 | * data to transform | |
| 232 | * @param scale | |
| 233 | * if true then scaling is performed | |
| 234 | */ | |
| 235 | public void complexInverse(double[] a, boolean scale) { | |
| 236 |
1
1. complexInverse : removed call to mikera/matrixx/algo/FFT::complexInverse → KILLED |
complexInverse(a, 0, scale); |
| 237 | } | |
| 238 | ||
| 239 | /** | |
| 240 | * Computes 1D inverse DFT of complex data leaving the result in | |
| 241 | * <code>a</code>. Complex number is stored as two double values in | |
| 242 | * sequence: the real and imaginary part, i.e. the size of the input array | |
| 243 | * must be greater or equal 2*n. The physical layout of the input data has | |
| 244 | * to be as follows:<br> | |
| 245 | * | |
| 246 | * <pre> | |
| 247 | * a[offa+2*k] = Re[k], | |
| 248 | * a[offa+2*k+1] = Im[k], 0<=k<n | |
| 249 | * </pre> | |
| 250 | * | |
| 251 | * @param a | |
| 252 | * data to transform | |
| 253 | * @param offa | |
| 254 | * index of the first element in array <code>a</code> | |
| 255 | * @param scale | |
| 256 | * if true then scaling is performed | |
| 257 | */ | |
| 258 | public void complexInverse(double[] a, int offa, boolean scale) { | |
| 259 |
1
1. complexInverse : negated conditional → KILLED |
if (n == 1) |
| 260 | return; | |
| 261 | switch (plan) { | |
| 262 | case SPLIT_RADIX: | |
| 263 |
2
1. complexInverse : Replaced integer multiplication with division → NO_COVERAGE 2. complexInverse : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * n, a, offa, ip, nw, w); |
| 264 | break; | |
| 265 | case MIXED_RADIX: | |
| 266 |
1
1. complexInverse : removed call to mikera/matrixx/algo/FFT::cfftf → KILLED |
cfftf(a, offa, +1); |
| 267 | break; | |
| 268 | case BLUESTEIN: | |
| 269 |
1
1. complexInverse : removed call to mikera/matrixx/algo/FFT::bluestein_complex → NO_COVERAGE |
bluestein_complex(a, offa, 1); |
| 270 | break; | |
| 271 | } | |
| 272 |
1
1. complexInverse : negated conditional → KILLED |
if (scale) { |
| 273 |
1
1. complexInverse : removed call to mikera/matrixx/algo/FFT::scale → KILLED |
scale(n, a, offa, true); |
| 274 | } | |
| 275 | } | |
| 276 | ||
| 277 | /** | |
| 278 | * Computes 1D forward DFT of real data leaving the result in <code>a</code> | |
| 279 | * . The physical layout of the output data is as follows:<br> | |
| 280 | * | |
| 281 | * if n is even then | |
| 282 | * | |
| 283 | * <pre> | |
| 284 | * a[2*k] = Re[k], 0<=k<n/2 | |
| 285 | * a[2*k+1] = Im[k], 0<k<n/2 | |
| 286 | * a[1] = Re[n/2] | |
| 287 | * </pre> | |
| 288 | * | |
| 289 | * if n is odd then | |
| 290 | * | |
| 291 | * <pre> | |
| 292 | * a[2*k] = Re[k], 0<=k<(n+1)/2 | |
| 293 | * a[2*k+1] = Im[k], 0<k<(n-1)/2 | |
| 294 | * a[1] = Im[(n-1)/2] | |
| 295 | * </pre> | |
| 296 | * | |
| 297 | * This method computes only half of the elements of the real transform. The | |
| 298 | * other half satisfies the symmetry condition. If you want the full real | |
| 299 | * forward transform, use <code>realForwardFull</code>. To get back the | |
| 300 | * original data, use <code>realInverse</code> on the output of this method. | |
| 301 | * | |
| 302 | * @param a | |
| 303 | * data to transform | |
| 304 | */ | |
| 305 | public void realForward(double[] a) { | |
| 306 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::realForward → NO_COVERAGE |
realForward(a, 0); |
| 307 | } | |
| 308 | ||
| 309 | /** | |
| 310 | * Computes 1D forward DFT of real data leaving the result in <code>a</code> | |
| 311 | * . The physical layout of the output data is as follows:<br> | |
| 312 | * | |
| 313 | * if n is even then | |
| 314 | * | |
| 315 | * <pre> | |
| 316 | * a[offa+2*k] = Re[k], 0<=k<n/2 | |
| 317 | * a[offa+2*k+1] = Im[k], 0<k<n/2 | |
| 318 | * a[offa+1] = Re[n/2] | |
| 319 | * </pre> | |
| 320 | * | |
| 321 | * if n is odd then | |
| 322 | * | |
| 323 | * <pre> | |
| 324 | * a[offa+2*k] = Re[k], 0<=k<(n+1)/2 | |
| 325 | * a[offa+2*k+1] = Im[k], 0<k<(n-1)/2 | |
| 326 | * a[offa+1] = Im[(n-1)/2] | |
| 327 | * </pre> | |
| 328 | * | |
| 329 | * This method computes only half of the elements of the real transform. The | |
| 330 | * other half satisfies the symmetry condition. If you want the full real | |
| 331 | * forward transform, use <code>realForwardFull</code>. To get back the | |
| 332 | * original data, use <code>realInverse</code> on the output of this method. | |
| 333 | * | |
| 334 | * @param a | |
| 335 | * data to transform | |
| 336 | * @param offa | |
| 337 | * index of the first element in array <code>a</code> | |
| 338 | */ | |
| 339 | public void realForward(double[] a, int offa) { | |
| 340 |
1
1. realForward : negated conditional → SURVIVED |
if (n == 1) |
| 341 | return; | |
| 342 | ||
| 343 | switch (plan) { | |
| 344 | case SPLIT_RADIX: | |
| 345 | double xi; | |
| 346 | ||
| 347 |
2
1. realForward : changed conditional boundary → NO_COVERAGE 2. realForward : negated conditional → NO_COVERAGE |
if (n > 4) { |
| 348 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(n, a, offa, ip, nw, w); |
| 349 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::rftfsub → NO_COVERAGE |
rftfsub(n, a, offa, nc, w, nw); |
| 350 |
1
1. realForward : negated conditional → NO_COVERAGE |
} else if (n == 4) { |
| 351 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::cftx020 → NO_COVERAGE |
cftx020(a, offa); |
| 352 | } | |
| 353 |
2
1. realForward : Replaced integer addition with subtraction → NO_COVERAGE 2. realForward : Replaced double subtraction with addition → NO_COVERAGE |
xi = a[offa] - a[offa + 1]; |
| 354 |
2
1. realForward : Replaced integer addition with subtraction → NO_COVERAGE 2. realForward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] += a[offa + 1]; |
| 355 |
1
1. realForward : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 1] = xi; |
| 356 | break; | |
| 357 | case MIXED_RADIX: | |
| 358 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::rfftf → NO_COVERAGE |
rfftf(a, offa); |
| 359 |
3
1. realForward : changed conditional boundary → NO_COVERAGE 2. realForward : Replaced integer subtraction with addition → NO_COVERAGE 3. realForward : negated conditional → NO_COVERAGE |
for (int k = n - 1; k >= 2; k--) { |
| 360 |
1
1. realForward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = offa + k; |
| 361 | double tmp = a[idx]; | |
| 362 |
1
1. realForward : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx] = a[idx - 1]; |
| 363 |
1
1. realForward : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx - 1] = tmp; |
| 364 | } | |
| 365 | break; | |
| 366 | case BLUESTEIN: | |
| 367 |
1
1. realForward : removed call to mikera/matrixx/algo/FFT::bluestein_real_forward → NO_COVERAGE |
bluestein_real_forward(a, offa); |
| 368 | break; | |
| 369 | } | |
| 370 | } | |
| 371 | ||
| 372 | /** | |
| 373 | * Computes 1D forward DFT of real data leaving the result in <code>a</code> | |
| 374 | * . This method computes the full real forward transform, i.e. you will get | |
| 375 | * the same result as from <code>complexForward</code> called with all | |
| 376 | * imaginary parts equal 0. Because the result is stored in <code>a</code>, | |
| 377 | * the size of the input array must greater or equal 2*n, with only the | |
| 378 | * first n elements filled with real data. To get back the original data, | |
| 379 | * use <code>complexInverse</code> on the output of this method. | |
| 380 | * | |
| 381 | * @param a | |
| 382 | * data to transform | |
| 383 | */ | |
| 384 | public void realForwardFull(double[] a) { | |
| 385 |
1
1. realForwardFull : removed call to mikera/matrixx/algo/FFT::realForwardFull → KILLED |
realForwardFull(a, 0); |
| 386 | } | |
| 387 | ||
| 388 | /** | |
| 389 | * Computes 1D forward DFT of real data leaving the result in <code>a</code> | |
| 390 | * . This method computes the full real forward transform, i.e. you will get | |
| 391 | * the same result as from <code>complexForward</code> called with all | |
| 392 | * imaginary part equal 0. Because the result is stored in <code>a</code>, | |
| 393 | * the size of the input array must greater or equal 2*n, with only the | |
| 394 | * first n elements filled with real data. To get back the original data, | |
| 395 | * use <code>complexInverse</code> on the output of this method. | |
| 396 | * | |
| 397 | * @param a | |
| 398 | * data to transform | |
| 399 | * @param offa | |
| 400 | * index of the first element in array <code>a</code> | |
| 401 | */ | |
| 402 | public void realForwardFull(final double[] a, final int offa) { | |
| 403 | ||
| 404 |
1
1. realForwardFull : Replaced integer multiplication with division → KILLED |
final int twon = 2 * n; |
| 405 | switch (plan) { | |
| 406 | case SPLIT_RADIX: | |
| 407 |
1
1. realForwardFull : removed call to mikera/matrixx/algo/FFT::realForward → SURVIVED |
realForward(a, offa); |
| 408 | { | |
| 409 | int idx1, idx2; | |
| 410 |
3
1. realForwardFull : changed conditional boundary → SURVIVED 2. realForwardFull : Replaced integer division with multiplication → KILLED 3. realForwardFull : negated conditional → KILLED |
for (int k = 0; k < n / 2; k++) { |
| 411 |
1
1. realForwardFull : Replaced integer multiplication with division → NO_COVERAGE |
idx1 = 2 * k; |
| 412 |
3
1. realForwardFull : Replaced integer subtraction with addition → NO_COVERAGE 2. realForwardFull : Replaced integer modulus with multiplication → NO_COVERAGE 3. realForwardFull : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + ((twon - idx1) % twon); |
| 413 |
1
1. realForwardFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2] = a[offa + idx1]; |
| 414 |
4
1. realForwardFull : removed negation → NO_COVERAGE 2. realForwardFull : Replaced integer addition with subtraction → NO_COVERAGE 3. realForwardFull : Replaced integer addition with subtraction → NO_COVERAGE 4. realForwardFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = -a[offa + idx1 + 1]; |
| 415 | } | |
| 416 | } | |
| 417 |
3
1. realForwardFull : removed negation → SURVIVED 2. realForwardFull : Replaced integer addition with subtraction → KILLED 3. realForwardFull : Replaced integer addition with subtraction → KILLED |
a[offa + n] = -a[offa + 1]; |
| 418 |
1
1. realForwardFull : Replaced integer addition with subtraction → KILLED |
a[offa + 1] = 0; |
| 419 | break; | |
| 420 | case MIXED_RADIX: | |
| 421 |
1
1. realForwardFull : removed call to mikera/matrixx/algo/FFT::rfftf → KILLED |
rfftf(a, offa); |
| 422 | int m; | |
| 423 |
2
1. realForwardFull : Replaced integer modulus with multiplication → SURVIVED 2. realForwardFull : negated conditional → KILLED |
if (n % 2 == 0) { |
| 424 |
1
1. realForwardFull : Replaced integer division with multiplication → NO_COVERAGE |
m = n / 2; |
| 425 | } else { | |
| 426 |
2
1. realForwardFull : Replaced integer addition with subtraction → KILLED 2. realForwardFull : Replaced integer division with multiplication → KILLED |
m = (n + 1) / 2; |
| 427 | } | |
| 428 |
2
1. realForwardFull : changed conditional boundary → KILLED 2. realForwardFull : negated conditional → KILLED |
for (int k = 1; k < m; k++) { |
| 429 |
3
1. realForwardFull : Replaced integer multiplication with division → SURVIVED 2. realForwardFull : Replaced integer addition with subtraction → KILLED 3. realForwardFull : Replaced integer subtraction with addition → KILLED |
int idx1 = offa + twon - 2 * k; |
| 430 |
2
1. realForwardFull : Replaced integer multiplication with division → SURVIVED 2. realForwardFull : Replaced integer addition with subtraction → KILLED |
int idx2 = offa + 2 * k; |
| 431 |
2
1. realForwardFull : removed negation → KILLED 2. realForwardFull : Replaced integer addition with subtraction → KILLED |
a[idx1 + 1] = -a[idx2]; |
| 432 |
1
1. realForwardFull : Replaced integer subtraction with addition → KILLED |
a[idx1] = a[idx2 - 1]; |
| 433 | } | |
| 434 |
2
1. realForwardFull : changed conditional boundary → KILLED 2. realForwardFull : negated conditional → KILLED |
for (int k = 1; k < n; k++) { |
| 435 |
2
1. realForwardFull : Replaced integer addition with subtraction → KILLED 2. realForwardFull : Replaced integer subtraction with addition → KILLED |
int idx = offa + n - k; |
| 436 |
1
1. realForwardFull : Replaced integer addition with subtraction → SURVIVED |
double tmp = a[idx + 1]; |
| 437 |
1
1. realForwardFull : Replaced integer addition with subtraction → KILLED |
a[idx + 1] = a[idx]; |
| 438 | a[idx] = tmp; | |
| 439 | } | |
| 440 |
1
1. realForwardFull : Replaced integer addition with subtraction → KILLED |
a[offa + 1] = 0; |
| 441 | break; | |
| 442 | case BLUESTEIN: | |
| 443 |
1
1. realForwardFull : removed call to mikera/matrixx/algo/FFT::bluestein_real_full → NO_COVERAGE |
bluestein_real_full(a, offa, -1); |
| 444 | break; | |
| 445 | } | |
| 446 | } | |
| 447 | ||
| 448 | /** | |
| 449 | * Computes 1D inverse DFT of real data leaving the result in <code>a</code> | |
| 450 | * . The physical layout of the input data has to be as follows:<br> | |
| 451 | * | |
| 452 | * if n is even then | |
| 453 | * | |
| 454 | * <pre> | |
| 455 | * a[2*k] = Re[k], 0<=k<n/2 | |
| 456 | * a[2*k+1] = Im[k], 0<k<n/2 | |
| 457 | * a[1] = Re[n/2] | |
| 458 | * </pre> | |
| 459 | * | |
| 460 | * if n is odd then | |
| 461 | * | |
| 462 | * <pre> | |
| 463 | * a[2*k] = Re[k], 0<=k<(n+1)/2 | |
| 464 | * a[2*k+1] = Im[k], 0<k<(n-1)/2 | |
| 465 | * a[1] = Im[(n-1)/2] | |
| 466 | * </pre> | |
| 467 | * | |
| 468 | * This method computes only half of the elements of the real transform. The | |
| 469 | * other half satisfies the symmetry condition. If you want the full real | |
| 470 | * inverse transform, use <code>realInverseFull</code>. | |
| 471 | * | |
| 472 | * @param a | |
| 473 | * data to transform | |
| 474 | * | |
| 475 | * @param scale | |
| 476 | * if true then scaling is performed | |
| 477 | * | |
| 478 | */ | |
| 479 | public void realInverse(double[] a, boolean scale) { | |
| 480 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::realInverse → NO_COVERAGE |
realInverse(a, 0, scale); |
| 481 | } | |
| 482 | ||
| 483 | /** | |
| 484 | * Computes 1D inverse DFT of real data leaving the result in <code>a</code> | |
| 485 | * . The physical layout of the input data has to be as follows:<br> | |
| 486 | * | |
| 487 | * if n is even then | |
| 488 | * | |
| 489 | * <pre> | |
| 490 | * a[offa+2*k] = Re[k], 0<=k<n/2 | |
| 491 | * a[offa+2*k+1] = Im[k], 0<k<n/2 | |
| 492 | * a[offa+1] = Re[n/2] | |
| 493 | * </pre> | |
| 494 | * | |
| 495 | * if n is odd then | |
| 496 | * | |
| 497 | * <pre> | |
| 498 | * a[offa+2*k] = Re[k], 0<=k<(n+1)/2 | |
| 499 | * a[offa+2*k+1] = Im[k], 0<k<(n-1)/2 | |
| 500 | * a[offa+1] = Im[(n-1)/2] | |
| 501 | * </pre> | |
| 502 | * | |
| 503 | * This method computes only half of the elements of the real transform. The | |
| 504 | * other half satisfies the symmetry condition. If you want the full real | |
| 505 | * inverse transform, use <code>realInverseFull</code>. | |
| 506 | * | |
| 507 | * @param a | |
| 508 | * data to transform | |
| 509 | * @param offa | |
| 510 | * index of the first element in array <code>a</code> | |
| 511 | * @param scale | |
| 512 | * if true then scaling is performed | |
| 513 | * | |
| 514 | */ | |
| 515 | public void realInverse(double[] a, int offa, boolean scale) { | |
| 516 |
1
1. realInverse : negated conditional → NO_COVERAGE |
if (n == 1) |
| 517 | return; | |
| 518 | switch (plan) { | |
| 519 | case SPLIT_RADIX: | |
| 520 |
4
1. realInverse : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverse : Replaced integer addition with subtraction → NO_COVERAGE 3. realInverse : Replaced double subtraction with addition → NO_COVERAGE 4. realInverse : Replaced double multiplication with division → NO_COVERAGE |
a[offa + 1] = 0.5 * (a[offa] - a[offa + 1]); |
| 521 |
2
1. realInverse : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverse : Replaced double subtraction with addition → NO_COVERAGE |
a[offa] -= a[offa + 1]; |
| 522 |
2
1. realInverse : changed conditional boundary → NO_COVERAGE 2. realInverse : negated conditional → NO_COVERAGE |
if (n > 4) { |
| 523 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::rftfsub → NO_COVERAGE |
rftfsub(n, a, offa, nc, w, nw); |
| 524 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(n, a, offa, ip, nw, w); |
| 525 |
1
1. realInverse : negated conditional → NO_COVERAGE |
} else if (n == 4) { |
| 526 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::cftxc020 → NO_COVERAGE |
cftxc020(a, offa); |
| 527 | } | |
| 528 |
1
1. realInverse : negated conditional → NO_COVERAGE |
if (scale) { |
| 529 |
2
1. realInverse : Replaced integer division with multiplication → NO_COVERAGE 2. realInverse : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n / 2, a, offa, false); |
| 530 | } | |
| 531 | break; | |
| 532 | case MIXED_RADIX: | |
| 533 |
2
1. realInverse : changed conditional boundary → NO_COVERAGE 2. realInverse : negated conditional → NO_COVERAGE |
for (int k = 2; k < n; k++) { |
| 534 |
1
1. realInverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = offa + k; |
| 535 |
1
1. realInverse : Replaced integer subtraction with addition → NO_COVERAGE |
double tmp = a[idx - 1]; |
| 536 |
1
1. realInverse : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx - 1] = a[idx]; |
| 537 | a[idx] = tmp; | |
| 538 | } | |
| 539 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::rfftb → NO_COVERAGE |
rfftb(a, offa); |
| 540 |
1
1. realInverse : negated conditional → NO_COVERAGE |
if (scale) { |
| 541 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 542 | } | |
| 543 | break; | |
| 544 | case BLUESTEIN: | |
| 545 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::bluestein_real_inverse → NO_COVERAGE |
bluestein_real_inverse(a, offa); |
| 546 |
1
1. realInverse : negated conditional → NO_COVERAGE |
if (scale) { |
| 547 |
1
1. realInverse : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 548 | } | |
| 549 | break; | |
| 550 | } | |
| 551 | ||
| 552 | } | |
| 553 | ||
| 554 | /** | |
| 555 | * Computes 1D inverse DFT of real data leaving the result in <code>a</code> | |
| 556 | * . This method computes the full real inverse transform, i.e. you will get | |
| 557 | * the same result as from <code>complexInverse</code> called with all | |
| 558 | * imaginary part equal 0. Because the result is stored in <code>a</code>, | |
| 559 | * the size of the input array must greater or equal 2*n, with only the | |
| 560 | * first n elements filled with real data. | |
| 561 | * | |
| 562 | * @param a | |
| 563 | * data to transform | |
| 564 | * @param scale | |
| 565 | * if true then scaling is performed | |
| 566 | */ | |
| 567 | public void realInverseFull(double[] a, boolean scale) { | |
| 568 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::realInverseFull → NO_COVERAGE |
realInverseFull(a, 0, scale); |
| 569 | } | |
| 570 | ||
| 571 | /** | |
| 572 | * Computes 1D inverse DFT of real data leaving the result in <code>a</code> | |
| 573 | * . This method computes the full real inverse transform, i.e. you will get | |
| 574 | * the same result as from <code>complexInverse</code> called with all | |
| 575 | * imaginary part equal 0. Because the result is stored in <code>a</code>, | |
| 576 | * the size of the input array must greater or equal 2*n, with only the | |
| 577 | * first n elements filled with real data. | |
| 578 | * | |
| 579 | * @param a | |
| 580 | * data to transform | |
| 581 | * @param offa | |
| 582 | * index of the first element in array <code>a</code> | |
| 583 | * @param scale | |
| 584 | * if true then scaling is performed | |
| 585 | */ | |
| 586 | public void realInverseFull(final double[] a, final int offa, boolean scale) { | |
| 587 |
1
1. realInverseFull : Replaced integer multiplication with division → NO_COVERAGE |
final int twon = 2 * n; |
| 588 | switch (plan) { | |
| 589 | case SPLIT_RADIX: | |
| 590 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::realInverse2 → NO_COVERAGE |
realInverse2(a, offa, scale); |
| 591 | { | |
| 592 | int idx1, idx2; | |
| 593 |
3
1. realInverseFull : changed conditional boundary → NO_COVERAGE 2. realInverseFull : Replaced integer division with multiplication → NO_COVERAGE 3. realInverseFull : negated conditional → NO_COVERAGE |
for (int k = 0; k < n / 2; k++) { |
| 594 |
1
1. realInverseFull : Replaced integer multiplication with division → NO_COVERAGE |
idx1 = 2 * k; |
| 595 |
3
1. realInverseFull : Replaced integer subtraction with addition → NO_COVERAGE 2. realInverseFull : Replaced integer modulus with multiplication → NO_COVERAGE 3. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + ((twon - idx1) % twon); |
| 596 |
1
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2] = a[offa + idx1]; |
| 597 |
4
1. realInverseFull : removed negation → NO_COVERAGE 2. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 3. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 4. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = -a[offa + idx1 + 1]; |
| 598 | } | |
| 599 | } | |
| 600 |
3
1. realInverseFull : removed negation → NO_COVERAGE 2. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 3. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + n] = -a[offa + 1]; |
| 601 |
1
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 1] = 0; |
| 602 | break; | |
| 603 | case MIXED_RADIX: | |
| 604 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::rfftf → NO_COVERAGE |
rfftf(a, offa); |
| 605 |
1
1. realInverseFull : negated conditional → NO_COVERAGE |
if (scale) { |
| 606 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 607 | } | |
| 608 | int m; | |
| 609 |
2
1. realInverseFull : Replaced integer modulus with multiplication → NO_COVERAGE 2. realInverseFull : negated conditional → NO_COVERAGE |
if (n % 2 == 0) { |
| 610 |
1
1. realInverseFull : Replaced integer division with multiplication → NO_COVERAGE |
m = n / 2; |
| 611 | } else { | |
| 612 |
2
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverseFull : Replaced integer division with multiplication → NO_COVERAGE |
m = (n + 1) / 2; |
| 613 | } | |
| 614 |
2
1. realInverseFull : changed conditional boundary → NO_COVERAGE 2. realInverseFull : negated conditional → NO_COVERAGE |
for (int k = 1; k < m; k++) { |
| 615 |
2
1. realInverseFull : Replaced integer multiplication with division → NO_COVERAGE 2. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = offa + 2 * k; |
| 616 |
3
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverseFull : Replaced integer multiplication with division → NO_COVERAGE 3. realInverseFull : Replaced integer subtraction with addition → NO_COVERAGE |
int idx2 = offa + twon - 2 * k; |
| 617 |
1
1. realInverseFull : removed negation → NO_COVERAGE |
a[idx1] = -a[idx1]; |
| 618 |
2
1. realInverseFull : removed negation → NO_COVERAGE 2. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = -a[idx1]; |
| 619 |
1
1. realInverseFull : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx2] = a[idx1 - 1]; |
| 620 | } | |
| 621 |
2
1. realInverseFull : changed conditional boundary → NO_COVERAGE 2. realInverseFull : negated conditional → NO_COVERAGE |
for (int k = 1; k < n; k++) { |
| 622 |
2
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverseFull : Replaced integer subtraction with addition → NO_COVERAGE |
int idx = offa + n - k; |
| 623 |
1
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
double tmp = a[idx + 1]; |
| 624 |
1
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx + 1] = a[idx]; |
| 625 | a[idx] = tmp; | |
| 626 | } | |
| 627 |
1
1. realInverseFull : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 1] = 0; |
| 628 | break; | |
| 629 | case BLUESTEIN: | |
| 630 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::bluestein_real_full → NO_COVERAGE |
bluestein_real_full(a, offa, 1); |
| 631 |
1
1. realInverseFull : negated conditional → NO_COVERAGE |
if (scale) { |
| 632 |
1
1. realInverseFull : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, true); |
| 633 | } | |
| 634 | break; | |
| 635 | } | |
| 636 | } | |
| 637 | ||
| 638 | protected void realInverse2(double[] a, int offa, boolean scale) { | |
| 639 |
1
1. realInverse2 : negated conditional → NO_COVERAGE |
if (n == 1) |
| 640 | return; | |
| 641 | switch (plan) { | |
| 642 | case SPLIT_RADIX: | |
| 643 | double xi; | |
| 644 | ||
| 645 |
2
1. realInverse2 : changed conditional boundary → NO_COVERAGE 2. realInverse2 : negated conditional → NO_COVERAGE |
if (n > 4) { |
| 646 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(n, a, offa, ip, nw, w); |
| 647 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::rftbsub → NO_COVERAGE |
rftbsub(n, a, offa, nc, w, nw); |
| 648 |
1
1. realInverse2 : negated conditional → NO_COVERAGE |
} else if (n == 4) { |
| 649 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(n, a, offa, ip, nw, w); |
| 650 | } | |
| 651 |
2
1. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverse2 : Replaced double subtraction with addition → NO_COVERAGE |
xi = a[offa] - a[offa + 1]; |
| 652 |
2
1. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. realInverse2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] += a[offa + 1]; |
| 653 |
1
1. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 1] = xi; |
| 654 |
1
1. realInverse2 : negated conditional → NO_COVERAGE |
if (scale) { |
| 655 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 656 | } | |
| 657 | break; | |
| 658 | case MIXED_RADIX: | |
| 659 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::rfftf → NO_COVERAGE |
rfftf(a, offa); |
| 660 |
3
1. realInverse2 : changed conditional boundary → NO_COVERAGE 2. realInverse2 : Replaced integer subtraction with addition → NO_COVERAGE 3. realInverse2 : negated conditional → NO_COVERAGE |
for (int k = n - 1; k >= 2; k--) { |
| 661 |
1
1. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = offa + k; |
| 662 | double tmp = a[idx]; | |
| 663 |
1
1. realInverse2 : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx] = a[idx - 1]; |
| 664 |
1
1. realInverse2 : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx - 1] = tmp; |
| 665 | } | |
| 666 |
1
1. realInverse2 : negated conditional → NO_COVERAGE |
if (scale) { |
| 667 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 668 | } | |
| 669 | int m; | |
| 670 |
2
1. realInverse2 : Replaced integer modulus with multiplication → NO_COVERAGE 2. realInverse2 : negated conditional → NO_COVERAGE |
if (n % 2 == 0) { |
| 671 |
1
1. realInverse2 : Replaced integer division with multiplication → NO_COVERAGE |
m = n / 2; |
| 672 |
2
1. realInverse2 : changed conditional boundary → NO_COVERAGE 2. realInverse2 : negated conditional → NO_COVERAGE |
for (int i = 1; i < m; i++) { |
| 673 |
3
1. realInverse2 : Replaced integer multiplication with division → NO_COVERAGE 2. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE 3. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = offa + 2 * i + 1; |
| 674 |
1
1. realInverse2 : removed negation → NO_COVERAGE |
a[idx] = -a[idx]; |
| 675 | } | |
| 676 | } else { | |
| 677 |
2
1. realInverse2 : Replaced integer subtraction with addition → NO_COVERAGE 2. realInverse2 : Replaced integer division with multiplication → NO_COVERAGE |
m = (n - 1) / 2; |
| 678 |
2
1. realInverse2 : changed conditional boundary → NO_COVERAGE 2. realInverse2 : negated conditional → NO_COVERAGE |
for (int i = 0; i < m; i++) { |
| 679 |
3
1. realInverse2 : Replaced integer multiplication with division → NO_COVERAGE 2. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE 3. realInverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = offa + 2 * i + 1; |
| 680 |
1
1. realInverse2 : removed negation → NO_COVERAGE |
a[idx] = -a[idx]; |
| 681 | } | |
| 682 | } | |
| 683 | break; | |
| 684 | case BLUESTEIN: | |
| 685 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::bluestein_real_inverse2 → NO_COVERAGE |
bluestein_real_inverse2(a, offa); |
| 686 |
1
1. realInverse2 : negated conditional → NO_COVERAGE |
if (scale) { |
| 687 |
1
1. realInverse2 : removed call to mikera/matrixx/algo/FFT::scale → NO_COVERAGE |
scale(n, a, offa, false); |
| 688 | } | |
| 689 | break; | |
| 690 | } | |
| 691 | } | |
| 692 | ||
| 693 | private static int getReminder(int n, int factors[]) { | |
| 694 | int reminder = n; | |
| 695 | ||
| 696 |
2
1. getReminder : changed conditional boundary → SURVIVED 2. getReminder : negated conditional → KILLED |
if (n <= 0) { |
| 697 | throw new IllegalArgumentException("n must be positive integer"); | |
| 698 | } | |
| 699 | ||
| 700 |
3
1. getReminder : changed conditional boundary → SURVIVED 2. getReminder : negated conditional → SURVIVED 3. getReminder : negated conditional → SURVIVED |
for (int i = 0; i < factors.length && reminder != 1; i++) { |
| 701 | int factor = factors[i]; | |
| 702 |
2
1. getReminder : Replaced integer modulus with multiplication → SURVIVED 2. getReminder : negated conditional → SURVIVED |
while ((reminder % factor) == 0) { |
| 703 |
1
1. getReminder : Replaced integer division with multiplication → SURVIVED |
reminder /= factor; |
| 704 | } | |
| 705 | } | |
| 706 |
1
1. getReminder : replaced int return with 0 for mikera/matrixx/algo/FFT::getReminder → SURVIVED |
return reminder; |
| 707 | } | |
| 708 | ||
| 709 | /* -------- initializing routines -------- */ | |
| 710 | ||
| 711 | /*--------------------------------------------------------- | |
| 712 | cffti: initialization of Complex FFT | |
| 713 | --------------------------------------------------------*/ | |
| 714 | ||
| 715 | void cffti(int n, int offw) { | |
| 716 |
1
1. cffti : negated conditional → NO_COVERAGE |
if (n == 1) |
| 717 | return; | |
| 718 | ||
| 719 |
1
1. cffti : Replaced integer multiplication with division → NO_COVERAGE |
final int twon = 2 * n; |
| 720 |
1
1. cffti : Replaced integer multiplication with division → NO_COVERAGE |
final int fourn = 4 * n; |
| 721 | double argh; | |
| 722 | int idot, ntry = 0, i, j; | |
| 723 | double argld; | |
| 724 | int i1, k1, l1, l2, ib; | |
| 725 | double fi; | |
| 726 | int ld, ii, nf, ip, nl, nq, nr; | |
| 727 | double arg; | |
| 728 | int ido, ipm; | |
| 729 | ||
| 730 | nl = n; | |
| 731 | nf = 0; | |
| 732 | j = 0; | |
| 733 | ||
| 734 | factorize_loop: while (true) { | |
| 735 |
1
1. cffti : Changed increment from 1 to -1 → NO_COVERAGE |
j++; |
| 736 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
if (j <= 4) |
| 737 |
1
1. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
ntry = factors[j - 1]; |
| 738 | else | |
| 739 |
1
1. cffti : Changed increment from 2 to -2 → NO_COVERAGE |
ntry += 2; |
| 740 | do { | |
| 741 |
1
1. cffti : Replaced integer division with multiplication → NO_COVERAGE |
nq = nl / ntry; |
| 742 |
2
1. cffti : Replaced integer multiplication with division → NO_COVERAGE 2. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
nr = nl - ntry * nq; |
| 743 |
1
1. cffti : negated conditional → NO_COVERAGE |
if (nr != 0) |
| 744 | continue factorize_loop; | |
| 745 |
1
1. cffti : Changed increment from 1 to -1 → NO_COVERAGE |
nf++; |
| 746 |
3
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE 3. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + nf + 1 + fourn] = ntry; |
| 747 | nl = nq; | |
| 748 |
2
1. cffti : negated conditional → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
if (ntry == 2 && nf != 1) { |
| 749 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
for (i = 2; i <= nf; i++) { |
| 750 |
2
1. cffti : Replaced integer subtraction with addition → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
ib = nf - i + 2; |
| 751 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = ib + fourn; |
| 752 |
3
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE 3. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + idx + 1] = wtable[offw + idx]; |
| 753 | } | |
| 754 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + 2 + fourn] = 2; |
| 755 | } | |
| 756 |
1
1. cffti : negated conditional → NO_COVERAGE |
} while (nl != 1); |
| 757 | break factorize_loop; | |
| 758 | } | |
| 759 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + fourn] = n; |
| 760 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + 1 + fourn] = nf; |
| 761 |
1
1. cffti : Replaced double division with multiplication → NO_COVERAGE |
argh = TWO_PI / n; |
| 762 | i = 1; | |
| 763 | l1 = 1; | |
| 764 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
for (k1 = 1; k1 <= nf; k1++) { |
| 765 |
3
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE 3. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
ip = (int) wtable[offw + k1 + 1 + fourn]; |
| 766 | ld = 0; | |
| 767 |
1
1. cffti : Replaced integer multiplication with division → NO_COVERAGE |
l2 = l1 * ip; |
| 768 |
1
1. cffti : Replaced integer division with multiplication → NO_COVERAGE |
ido = n / l2; |
| 769 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
idot = ido + ido + 2; |
| 770 |
1
1. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
ipm = ip - 1; |
| 771 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
for (j = 1; j <= ipm; j++) { |
| 772 | i1 = i; | |
| 773 |
3
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer subtraction with addition → NO_COVERAGE 3. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + i - 1 + twon] = 1; |
| 774 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + i + twon] = 0; |
| 775 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
ld += l1; |
| 776 | fi = 0; | |
| 777 |
1
1. cffti : Replaced double multiplication with division → NO_COVERAGE |
argld = ld * argh; |
| 778 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
for (ii = 4; ii <= idot; ii += 2) { |
| 779 |
1
1. cffti : Changed increment from 2 to -2 → NO_COVERAGE |
i += 2; |
| 780 |
1
1. cffti : Replaced double addition with subtraction → NO_COVERAGE |
fi += 1; |
| 781 |
1
1. cffti : Replaced double multiplication with division → NO_COVERAGE |
arg = fi * argld; |
| 782 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = i + twon; |
| 783 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
wtable[offw + idx - 1] = Math.cos(arg); |
| 784 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + idx] = Math.sin(arg); |
| 785 | } | |
| 786 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
if (ip > 5) { |
| 787 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = i1 + twon; |
| 788 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = i + twon; |
| 789 |
4
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer subtraction with addition → NO_COVERAGE 3. cffti : Replaced integer addition with subtraction → NO_COVERAGE 4. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
wtable[offw + idx1 - 1] = wtable[offw + idx2 - 1]; |
| 790 |
2
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[offw + idx1] = wtable[offw + idx2]; |
| 791 | } | |
| 792 | } | |
| 793 | l1 = l2; | |
| 794 | } | |
| 795 | ||
| 796 | } | |
| 797 | ||
| 798 | void cffti() { | |
| 799 |
1
1. cffti : negated conditional → KILLED |
if (n == 1) |
| 800 | return; | |
| 801 | ||
| 802 |
1
1. cffti : Replaced integer multiplication with division → SURVIVED |
final int twon = 2 * n; |
| 803 |
1
1. cffti : Replaced integer multiplication with division → KILLED |
final int fourn = 4 * n; |
| 804 | double argh; | |
| 805 | int idot, ntry = 0, i, j; | |
| 806 | double argld; | |
| 807 | int i1, k1, l1, l2, ib; | |
| 808 | double fi; | |
| 809 | int ld, ii, nf, ip, nl, nq, nr; | |
| 810 | double arg; | |
| 811 | int ido, ipm; | |
| 812 | ||
| 813 | nl = n; | |
| 814 | nf = 0; | |
| 815 | j = 0; | |
| 816 | ||
| 817 | factorize_loop: while (true) { | |
| 818 |
1
1. cffti : Changed increment from 1 to -1 → KILLED |
j++; |
| 819 |
2
1. cffti : changed conditional boundary → SURVIVED 2. cffti : negated conditional → KILLED |
if (j <= 4) |
| 820 |
1
1. cffti : Replaced integer subtraction with addition → SURVIVED |
ntry = factors[j - 1]; |
| 821 | else | |
| 822 |
1
1. cffti : Changed increment from 2 to -2 → NO_COVERAGE |
ntry += 2; |
| 823 | do { | |
| 824 |
1
1. cffti : Replaced integer division with multiplication → KILLED |
nq = nl / ntry; |
| 825 |
2
1. cffti : Replaced integer subtraction with addition → TIMED_OUT 2. cffti : Replaced integer multiplication with division → KILLED |
nr = nl - ntry * nq; |
| 826 |
1
1. cffti : negated conditional → TIMED_OUT |
if (nr != 0) |
| 827 | continue factorize_loop; | |
| 828 |
1
1. cffti : Changed increment from 1 to -1 → KILLED |
nf++; |
| 829 |
2
1. cffti : Replaced integer addition with subtraction → KILLED 2. cffti : Replaced integer addition with subtraction → KILLED |
wtable[nf + 1 + fourn] = ntry; |
| 830 | nl = nq; | |
| 831 |
2
1. cffti : negated conditional → SURVIVED 2. cffti : negated conditional → NO_COVERAGE |
if (ntry == 2 && nf != 1) { |
| 832 |
2
1. cffti : changed conditional boundary → NO_COVERAGE 2. cffti : negated conditional → NO_COVERAGE |
for (i = 2; i <= nf; i++) { |
| 833 |
2
1. cffti : Replaced integer subtraction with addition → NO_COVERAGE 2. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
ib = nf - i + 2; |
| 834 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = ib + fourn; |
| 835 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[idx + 1] = wtable[idx]; |
| 836 | } | |
| 837 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable[2 + fourn] = 2; |
| 838 | } | |
| 839 |
1
1. cffti : negated conditional → TIMED_OUT |
} while (nl != 1); |
| 840 | break factorize_loop; | |
| 841 | } | |
| 842 | wtable[fourn] = n; | |
| 843 |
1
1. cffti : Replaced integer addition with subtraction → KILLED |
wtable[1 + fourn] = nf; |
| 844 |
1
1. cffti : Replaced double division with multiplication → SURVIVED |
argh = TWO_PI / n; |
| 845 | i = 1; | |
| 846 | l1 = 1; | |
| 847 |
2
1. cffti : changed conditional boundary → SURVIVED 2. cffti : negated conditional → SURVIVED |
for (k1 = 1; k1 <= nf; k1++) { |
| 848 |
2
1. cffti : Replaced integer addition with subtraction → SURVIVED 2. cffti : Replaced integer addition with subtraction → KILLED |
ip = (int) wtable[k1 + 1 + fourn]; |
| 849 | ld = 0; | |
| 850 |
1
1. cffti : Replaced integer multiplication with division → KILLED |
l2 = l1 * ip; |
| 851 |
1
1. cffti : Replaced integer division with multiplication → KILLED |
ido = n / l2; |
| 852 |
2
1. cffti : Replaced integer addition with subtraction → SURVIVED 2. cffti : Replaced integer addition with subtraction → SURVIVED |
idot = ido + ido + 2; |
| 853 |
1
1. cffti : Replaced integer subtraction with addition → KILLED |
ipm = ip - 1; |
| 854 |
2
1. cffti : changed conditional boundary → SURVIVED 2. cffti : negated conditional → SURVIVED |
for (j = 1; j <= ipm; j++) { |
| 855 | i1 = i; | |
| 856 |
2
1. cffti : Replaced integer subtraction with addition → SURVIVED 2. cffti : Replaced integer addition with subtraction → KILLED |
wtable[i - 1 + twon] = 1; |
| 857 |
1
1. cffti : Replaced integer addition with subtraction → KILLED |
wtable[i + twon] = 0; |
| 858 |
1
1. cffti : Replaced integer addition with subtraction → SURVIVED |
ld += l1; |
| 859 | fi = 0; | |
| 860 |
1
1. cffti : Replaced double multiplication with division → SURVIVED |
argld = ld * argh; |
| 861 |
2
1. cffti : changed conditional boundary → SURVIVED 2. cffti : negated conditional → SURVIVED |
for (ii = 4; ii <= idot; ii += 2) { |
| 862 |
1
1. cffti : Changed increment from 2 to -2 → SURVIVED |
i += 2; |
| 863 |
1
1. cffti : Replaced double addition with subtraction → SURVIVED |
fi += 1; |
| 864 |
1
1. cffti : Replaced double multiplication with division → SURVIVED |
arg = fi * argld; |
| 865 |
1
1. cffti : Replaced integer addition with subtraction → KILLED |
int idx = i + twon; |
| 866 |
1
1. cffti : Replaced integer subtraction with addition → SURVIVED |
wtable[idx - 1] = Math.cos(arg); |
| 867 | wtable[idx] = Math.sin(arg); | |
| 868 | } | |
| 869 |
2
1. cffti : changed conditional boundary → SURVIVED 2. cffti : negated conditional → SURVIVED |
if (ip > 5) { |
| 870 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = i1 + twon; |
| 871 |
1
1. cffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = i + twon; |
| 872 |
2
1. cffti : Replaced integer subtraction with addition → NO_COVERAGE 2. cffti : Replaced integer subtraction with addition → NO_COVERAGE |
wtable[idx1 - 1] = wtable[idx2 - 1]; |
| 873 | wtable[idx1] = wtable[idx2]; | |
| 874 | } | |
| 875 | } | |
| 876 | l1 = l2; | |
| 877 | } | |
| 878 | ||
| 879 | } | |
| 880 | ||
| 881 | void rffti() { | |
| 882 | ||
| 883 |
1
1. rffti : negated conditional → KILLED |
if (n == 1) |
| 884 | return; | |
| 885 |
1
1. rffti : Replaced integer multiplication with division → KILLED |
final int twon = 2 * n; |
| 886 | double argh; | |
| 887 | int ntry = 0, i, j; | |
| 888 | double argld; | |
| 889 | int k1, l1, l2, ib; | |
| 890 | double fi; | |
| 891 | int ld, ii, nf, ip, nl, is, nq, nr; | |
| 892 | double arg; | |
| 893 | int ido, ipm; | |
| 894 | int nfm1; | |
| 895 | ||
| 896 | nl = n; | |
| 897 | nf = 0; | |
| 898 | j = 0; | |
| 899 | ||
| 900 | factorize_loop: while (true) { | |
| 901 |
1
1. rffti : Changed increment from 1 to -1 → KILLED |
++j; |
| 902 |
2
1. rffti : changed conditional boundary → SURVIVED 2. rffti : negated conditional → KILLED |
if (j <= 4) |
| 903 |
1
1. rffti : Replaced integer subtraction with addition → SURVIVED |
ntry = factors[j - 1]; |
| 904 | else | |
| 905 |
1
1. rffti : Changed increment from 2 to -2 → NO_COVERAGE |
ntry += 2; |
| 906 | do { | |
| 907 |
1
1. rffti : Replaced integer division with multiplication → KILLED |
nq = nl / ntry; |
| 908 |
2
1. rffti : Replaced integer subtraction with addition → TIMED_OUT 2. rffti : Replaced integer multiplication with division → KILLED |
nr = nl - ntry * nq; |
| 909 |
1
1. rffti : negated conditional → TIMED_OUT |
if (nr != 0) |
| 910 | continue factorize_loop; | |
| 911 |
1
1. rffti : Changed increment from 1 to -1 → KILLED |
++nf; |
| 912 |
2
1. rffti : Replaced integer addition with subtraction → KILLED 2. rffti : Replaced integer addition with subtraction → KILLED |
wtable_r[nf + 1 + twon] = ntry; |
| 913 | ||
| 914 | nl = nq; | |
| 915 |
2
1. rffti : negated conditional → SURVIVED 2. rffti : negated conditional → NO_COVERAGE |
if (ntry == 2 && nf != 1) { |
| 916 |
2
1. rffti : changed conditional boundary → NO_COVERAGE 2. rffti : negated conditional → NO_COVERAGE |
for (i = 2; i <= nf; i++) { |
| 917 |
2
1. rffti : Replaced integer subtraction with addition → NO_COVERAGE 2. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
ib = nf - i + 2; |
| 918 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = ib + twon; |
| 919 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable_r[idx + 1] = wtable_r[idx]; |
| 920 | } | |
| 921 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
wtable_r[2 + twon] = 2; |
| 922 | } | |
| 923 |
1
1. rffti : negated conditional → TIMED_OUT |
} while (nl != 1); |
| 924 | break factorize_loop; | |
| 925 | } | |
| 926 | wtable_r[twon] = n; | |
| 927 |
1
1. rffti : Replaced integer addition with subtraction → KILLED |
wtable_r[1 + twon] = nf; |
| 928 |
1
1. rffti : Replaced double division with multiplication → SURVIVED |
argh = TWO_PI / (n); |
| 929 | is = 0; | |
| 930 |
1
1. rffti : Replaced integer subtraction with addition → KILLED |
nfm1 = nf - 1; |
| 931 | l1 = 1; | |
| 932 |
1
1. rffti : negated conditional → SURVIVED |
if (nfm1 == 0) |
| 933 | return; | |
| 934 |
2
1. rffti : changed conditional boundary → NO_COVERAGE 2. rffti : negated conditional → NO_COVERAGE |
for (k1 = 1; k1 <= nfm1; k1++) { |
| 935 |
2
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE 2. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
ip = (int) wtable_r[k1 + 1 + twon]; |
| 936 | ld = 0; | |
| 937 |
1
1. rffti : Replaced integer multiplication with division → NO_COVERAGE |
l2 = l1 * ip; |
| 938 |
1
1. rffti : Replaced integer division with multiplication → NO_COVERAGE |
ido = n / l2; |
| 939 |
1
1. rffti : Replaced integer subtraction with addition → NO_COVERAGE |
ipm = ip - 1; |
| 940 |
2
1. rffti : changed conditional boundary → NO_COVERAGE 2. rffti : negated conditional → NO_COVERAGE |
for (j = 1; j <= ipm; ++j) { |
| 941 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
ld += l1; |
| 942 | i = is; | |
| 943 |
1
1. rffti : Replaced double multiplication with division → NO_COVERAGE |
argld = ld * argh; |
| 944 | ||
| 945 | fi = 0; | |
| 946 |
2
1. rffti : changed conditional boundary → NO_COVERAGE 2. rffti : negated conditional → NO_COVERAGE |
for (ii = 3; ii <= ido; ii += 2) { |
| 947 |
1
1. rffti : Changed increment from 2 to -2 → NO_COVERAGE |
i += 2; |
| 948 |
1
1. rffti : Replaced double addition with subtraction → NO_COVERAGE |
fi += 1; |
| 949 |
1
1. rffti : Replaced double multiplication with division → NO_COVERAGE |
arg = fi * argld; |
| 950 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
int idx = i + n; |
| 951 |
1
1. rffti : Replaced integer subtraction with addition → NO_COVERAGE |
wtable_r[idx - 2] = Math.cos(arg); |
| 952 |
1
1. rffti : Replaced integer subtraction with addition → NO_COVERAGE |
wtable_r[idx - 1] = Math.sin(arg); |
| 953 | } | |
| 954 |
1
1. rffti : Replaced integer addition with subtraction → NO_COVERAGE |
is += ido; |
| 955 | } | |
| 956 | l1 = l2; | |
| 957 | } | |
| 958 | } | |
| 959 | ||
| 960 | private void bluesteini() { | |
| 961 | int k = 0; | |
| 962 | double arg; | |
| 963 |
1
1. bluesteini : Replaced double division with multiplication → NO_COVERAGE |
double pi_n = PI / n; |
| 964 | bk1[0] = 1; | |
| 965 | bk1[1] = 0; | |
| 966 |
2
1. bluesteini : changed conditional boundary → NO_COVERAGE 2. bluesteini : negated conditional → NO_COVERAGE |
for (int i = 1; i < n; i++) { |
| 967 |
3
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : Replaced integer subtraction with addition → NO_COVERAGE 3. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE |
k += 2 * i - 1; |
| 968 |
3
1. bluesteini : changed conditional boundary → NO_COVERAGE 2. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 3. bluesteini : negated conditional → NO_COVERAGE |
if (k >= 2 * n) |
| 969 |
2
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : Replaced integer subtraction with addition → NO_COVERAGE |
k -= 2 * n; |
| 970 |
1
1. bluesteini : Replaced double multiplication with division → NO_COVERAGE |
arg = pi_n * k; |
| 971 |
1
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE |
bk1[2 * i] = Math.cos(arg); |
| 972 |
2
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE |
bk1[2 * i + 1] = Math.sin(arg); |
| 973 | } | |
| 974 |
1
1. bluesteini : Replaced double division with multiplication → NO_COVERAGE |
double scale = 1.0 / nBluestein; |
| 975 |
1
1. bluesteini : Replaced double multiplication with division → NO_COVERAGE |
bk2[0] = bk1[0] * scale; |
| 976 |
1
1. bluesteini : Replaced double multiplication with division → NO_COVERAGE |
bk2[1] = bk1[1] * scale; |
| 977 |
3
1. bluesteini : changed conditional boundary → NO_COVERAGE 2. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 3. bluesteini : negated conditional → NO_COVERAGE |
for (int i = 2; i < 2 * n; i += 2) { |
| 978 |
1
1. bluesteini : Replaced double multiplication with division → NO_COVERAGE |
bk2[i] = bk1[i] * scale; |
| 979 |
3
1. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE 2. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE 3. bluesteini : Replaced double multiplication with division → NO_COVERAGE |
bk2[i + 1] = bk1[i + 1] * scale; |
| 980 |
2
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : Replaced integer subtraction with addition → NO_COVERAGE |
bk2[2 * nBluestein - i] = bk2[i]; |
| 981 |
4
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : Replaced integer subtraction with addition → NO_COVERAGE 3. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE 4. bluesteini : Replaced integer addition with subtraction → NO_COVERAGE |
bk2[2 * nBluestein - i + 1] = bk2[i + 1]; |
| 982 | } | |
| 983 |
2
1. bluesteini : Replaced integer multiplication with division → NO_COVERAGE 2. bluesteini : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, bk2, 0, ip, nw, w); |
| 984 | } | |
| 985 | ||
| 986 | private void makewt(int nw) { | |
| 987 | int j, nwh, nw0, nw1; | |
| 988 | double delta, wn4r, wk1r, wk1i, wk3r, wk3i; | |
| 989 | double delta2, deltaj, deltaj3; | |
| 990 | ||
| 991 | ip[0] = nw; | |
| 992 | ip[1] = 1; | |
| 993 |
2
1. makewt : changed conditional boundary → SURVIVED 2. makewt : negated conditional → KILLED |
if (nw > 2) { |
| 994 |
1
1. makewt : Replaced Shift Right with Shift Left → NO_COVERAGE |
nwh = nw >> 1; |
| 995 |
1
1. makewt : Replaced double division with multiplication → NO_COVERAGE |
delta = 0.785398163397448278999490867136046290 / nwh; |
| 996 |
1
1. makewt : Replaced double multiplication with division → NO_COVERAGE |
delta2 = delta * 2; |
| 997 |
1
1. makewt : Replaced double multiplication with division → NO_COVERAGE |
wn4r = Math.cos(delta * nwh); |
| 998 | w[0] = 1; | |
| 999 | w[1] = wn4r; | |
| 1000 |
1
1. makewt : negated conditional → NO_COVERAGE |
if (nwh == 4) { |
| 1001 | w[2] = Math.cos(delta2); | |
| 1002 | w[3] = Math.sin(delta2); | |
| 1003 |
2
1. makewt : changed conditional boundary → NO_COVERAGE 2. makewt : negated conditional → NO_COVERAGE |
} else if (nwh > 4) { |
| 1004 |
1
1. makewt : removed call to mikera/matrixx/algo/FFT::makeipt → NO_COVERAGE |
makeipt(nw); |
| 1005 |
1
1. makewt : Replaced double division with multiplication → NO_COVERAGE |
w[2] = 0.5 / Math.cos(delta2); |
| 1006 |
2
1. makewt : Replaced double multiplication with division → NO_COVERAGE 2. makewt : Replaced double division with multiplication → NO_COVERAGE |
w[3] = 0.5 / Math.cos(delta * 6); |
| 1007 |
2
1. makewt : changed conditional boundary → NO_COVERAGE 2. makewt : negated conditional → NO_COVERAGE |
for (j = 4; j < nwh; j += 4) { |
| 1008 |
1
1. makewt : Replaced double multiplication with division → NO_COVERAGE |
deltaj = delta * j; |
| 1009 |
1
1. makewt : Replaced double multiplication with division → NO_COVERAGE |
deltaj3 = 3 * deltaj; |
| 1010 | w[j] = Math.cos(deltaj); | |
| 1011 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[j + 1] = Math.sin(deltaj); |
| 1012 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[j + 2] = Math.cos(deltaj3); |
| 1013 |
2
1. makewt : removed negation → NO_COVERAGE 2. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[j + 3] = -Math.sin(deltaj3); |
| 1014 | } | |
| 1015 | } | |
| 1016 | nw0 = 0; | |
| 1017 |
2
1. makewt : changed conditional boundary → NO_COVERAGE 2. makewt : negated conditional → NO_COVERAGE |
while (nwh > 2) { |
| 1018 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
nw1 = nw0 + nwh; |
| 1019 |
1
1. makewt : Replaced Shift Right with Shift Left → NO_COVERAGE |
nwh >>= 1; |
| 1020 | w[nw1] = 1; | |
| 1021 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[nw1 + 1] = wn4r; |
| 1022 |
1
1. makewt : negated conditional → NO_COVERAGE |
if (nwh == 4) { |
| 1023 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[nw0 + 4]; |
| 1024 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[nw0 + 5]; |
| 1025 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[nw1 + 2] = wk1r; |
| 1026 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[nw1 + 3] = wk1i; |
| 1027 |
2
1. makewt : changed conditional boundary → NO_COVERAGE 2. makewt : negated conditional → NO_COVERAGE |
} else if (nwh > 4) { |
| 1028 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[nw0 + 4]; |
| 1029 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk3r = w[nw0 + 6]; |
| 1030 |
2
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE 2. makewt : Replaced double division with multiplication → NO_COVERAGE |
w[nw1 + 2] = 0.5 / wk1r; |
| 1031 |
2
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE 2. makewt : Replaced double division with multiplication → NO_COVERAGE |
w[nw1 + 3] = 0.5 / wk3r; |
| 1032 |
2
1. makewt : changed conditional boundary → NO_COVERAGE 2. makewt : negated conditional → NO_COVERAGE |
for (j = 4; j < nwh; j += 4) { |
| 1033 |
2
1. makewt : Replaced integer multiplication with division → NO_COVERAGE 2. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = nw0 + 2 * j; |
| 1034 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = nw1 + j; |
| 1035 | wk1r = w[idx1]; | |
| 1036 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[idx1 + 1]; |
| 1037 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk3r = w[idx1 + 2]; |
| 1038 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
wk3i = w[idx1 + 3]; |
| 1039 | w[idx2] = wk1r; | |
| 1040 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[idx2 + 1] = wk1i; |
| 1041 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[idx2 + 2] = wk3r; |
| 1042 |
1
1. makewt : Replaced integer addition with subtraction → NO_COVERAGE |
w[idx2 + 3] = wk3i; |
| 1043 | } | |
| 1044 | } | |
| 1045 | nw0 = nw1; | |
| 1046 | } | |
| 1047 | } | |
| 1048 | } | |
| 1049 | ||
| 1050 | private void makeipt(int nw) { | |
| 1051 | int j, l, m, m2, p, q; | |
| 1052 | ||
| 1053 | ip[2] = 0; | |
| 1054 | ip[3] = 16; | |
| 1055 | m = 2; | |
| 1056 |
3
1. makeipt : changed conditional boundary → NO_COVERAGE 2. makeipt : Replaced Shift Right with Shift Left → NO_COVERAGE 3. makeipt : negated conditional → NO_COVERAGE |
for (l = nw; l > 32; l >>= 2) { |
| 1057 |
1
1. makeipt : Replaced Shift Left with Shift Right → NO_COVERAGE |
m2 = m << 1; |
| 1058 |
1
1. makeipt : Replaced Shift Left with Shift Right → NO_COVERAGE |
q = m2 << 3; |
| 1059 |
2
1. makeipt : changed conditional boundary → NO_COVERAGE 2. makeipt : negated conditional → NO_COVERAGE |
for (j = m; j < m2; j++) { |
| 1060 |
1
1. makeipt : Replaced Shift Left with Shift Right → NO_COVERAGE |
p = ip[j] << 2; |
| 1061 |
1
1. makeipt : Replaced integer addition with subtraction → NO_COVERAGE |
ip[m + j] = p; |
| 1062 |
2
1. makeipt : Replaced integer addition with subtraction → NO_COVERAGE 2. makeipt : Replaced integer addition with subtraction → NO_COVERAGE |
ip[m2 + j] = p + q; |
| 1063 | } | |
| 1064 | m = m2; | |
| 1065 | } | |
| 1066 | } | |
| 1067 | ||
| 1068 | private void makect(int nc, double[] c, int startc) { | |
| 1069 | int j, nch; | |
| 1070 | double delta, deltaj; | |
| 1071 | ||
| 1072 | ip[1] = nc; | |
| 1073 |
2
1. makect : changed conditional boundary → NO_COVERAGE 2. makect : negated conditional → NO_COVERAGE |
if (nc > 1) { |
| 1074 |
1
1. makect : Replaced Shift Right with Shift Left → NO_COVERAGE |
nch = nc >> 1; |
| 1075 |
1
1. makect : Replaced double division with multiplication → NO_COVERAGE |
delta = 0.785398163397448278999490867136046290 / nch; |
| 1076 |
1
1. makect : Replaced double multiplication with division → NO_COVERAGE |
c[startc] = Math.cos(delta * nch); |
| 1077 |
2
1. makect : Replaced integer addition with subtraction → NO_COVERAGE 2. makect : Replaced double multiplication with division → NO_COVERAGE |
c[startc + nch] = 0.5 * c[startc]; |
| 1078 |
2
1. makect : changed conditional boundary → NO_COVERAGE 2. makect : negated conditional → NO_COVERAGE |
for (j = 1; j < nch; j++) { |
| 1079 |
1
1. makect : Replaced double multiplication with division → NO_COVERAGE |
deltaj = delta * j; |
| 1080 |
2
1. makect : Replaced integer addition with subtraction → NO_COVERAGE 2. makect : Replaced double multiplication with division → NO_COVERAGE |
c[startc + j] = 0.5 * Math.cos(deltaj); |
| 1081 |
3
1. makect : Replaced integer addition with subtraction → NO_COVERAGE 2. makect : Replaced integer subtraction with addition → NO_COVERAGE 3. makect : Replaced double multiplication with division → NO_COVERAGE |
c[startc + nc - j] = 0.5 * Math.sin(deltaj); |
| 1082 | } | |
| 1083 | } | |
| 1084 | } | |
| 1085 | ||
| 1086 | private void bluestein_complex(final double[] a, final int offa, final int isign) { | |
| 1087 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
final double[] ak = new double[2 * nBluestein]; |
| 1088 | { | |
| 1089 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1090 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1091 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1092 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1093 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1094 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1095 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2]; |
| 1096 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1]; |
| 1097 | } | |
| 1098 | } else { | |
| 1099 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1100 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1101 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1102 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1103 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1104 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2]; |
| 1105 |
4
1. bluestein_complex : removed negation → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx2] = -a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1]; |
| 1106 | } | |
| 1107 | } | |
| 1108 | ||
| 1109 |
2
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_complex : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1110 | ||
| 1111 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1112 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1113 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1114 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1115 |
4
1. bluestein_complex : removed negation → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
double im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1116 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2]; |
| 1117 | ak[idx2] = im; | |
| 1118 | } | |
| 1119 | } else { | |
| 1120 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1121 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1122 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1123 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
double im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1124 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2]; |
| 1125 | ak[idx2] = im; | |
| 1126 | } | |
| 1127 | } | |
| 1128 | ||
| 1129 |
2
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_complex : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1130 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1131 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1132 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1133 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1134 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1135 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1136 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2]; |
| 1137 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
a[idx4] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1138 | } | |
| 1139 | } else { | |
| 1140 |
2
1. bluestein_complex : changed conditional boundary → NO_COVERAGE 2. bluestein_complex : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1141 |
1
1. bluestein_complex : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1142 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1143 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1144 |
1
1. bluestein_complex : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1145 |
3
1. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2]; |
| 1146 |
4
1. bluestein_complex : removed negation → NO_COVERAGE 2. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_complex : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_complex : Replaced double addition with subtraction → NO_COVERAGE |
a[idx4] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1147 | } | |
| 1148 | } | |
| 1149 | } | |
| 1150 | } | |
| 1151 | ||
| 1152 | private void bluestein_real_full(final double[] a, final int offa, final int isign) { | |
| 1153 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
final double[] ak = new double[2 * nBluestein]; |
| 1154 | { | |
| 1155 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1156 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1157 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1158 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1159 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + i; |
| 1160 |
1
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1]; |
| 1161 |
1
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2]; |
| 1162 | } | |
| 1163 | } else { | |
| 1164 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1165 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1166 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1167 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + i; |
| 1168 |
1
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1]; |
| 1169 |
2
1. bluestein_real_full : removed negation → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE |
ak[idx2] = -a[idx3] * bk1[idx2]; |
| 1170 | } | |
| 1171 | } | |
| 1172 | ||
| 1173 |
2
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_full : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1174 | ||
| 1175 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1176 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1177 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1178 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1179 |
4
1. bluestein_real_full : removed negation → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
double im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1180 |
3
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2]; |
| 1181 | ak[idx2] = im; | |
| 1182 | } | |
| 1183 | } else { | |
| 1184 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1185 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1186 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1187 |
3
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
double im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1188 |
3
1. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2]; |
| 1189 | ak[idx2] = im; | |
| 1190 | } | |
| 1191 | } | |
| 1192 | ||
| 1193 |
2
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_full : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1194 | ||
| 1195 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
if (isign > 0) { |
| 1196 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1197 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1198 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1199 |
4
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_full : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2]; |
| 1200 |
4
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1201 | } | |
| 1202 | } else { | |
| 1203 |
2
1. bluestein_real_full : changed conditional boundary → NO_COVERAGE 2. bluestein_real_full : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1204 |
1
1. bluestein_real_full : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1205 |
1
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1206 |
4
1. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2]; |
| 1207 |
5
1. bluestein_real_full : removed negation → NO_COVERAGE 2. bluestein_real_full : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_full : Replaced double multiplication with division → NO_COVERAGE 5. bluestein_real_full : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1208 | } | |
| 1209 | } | |
| 1210 | } | |
| 1211 | } | |
| 1212 | ||
| 1213 | private void bluestein_real_forward(final double[] a, final int offa) { | |
| 1214 |
1
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE |
final double[] ak = new double[2 * nBluestein]; |
| 1215 | { | |
| 1216 |
2
1. bluestein_real_forward : changed conditional boundary → NO_COVERAGE 2. bluestein_real_forward : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1217 |
1
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1218 |
1
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1219 |
1
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + i; |
| 1220 |
1
1. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1]; |
| 1221 |
2
1. bluestein_real_forward : removed negation → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE |
ak[idx2] = -a[idx3] * bk1[idx2]; |
| 1222 | } | |
| 1223 | ||
| 1224 |
2
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_forward : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1225 | ||
| 1226 |
2
1. bluestein_real_forward : changed conditional boundary → NO_COVERAGE 2. bluestein_real_forward : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1227 |
1
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1228 |
1
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1229 |
3
1. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
double im = ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1230 |
3
1. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] - ak[idx2] * bk2[idx2]; |
| 1231 | ak[idx2] = im; | |
| 1232 | } | |
| 1233 | } | |
| 1234 | ||
| 1235 |
2
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_forward : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1236 | ||
| 1237 |
2
1. bluestein_real_forward : Replaced integer modulus with multiplication → NO_COVERAGE 2. bluestein_real_forward : negated conditional → NO_COVERAGE |
if (n % 2 == 0) { |
| 1238 |
3
1. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1]; |
| 1239 |
6
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 4. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = bk1[n] * ak[n] + bk1[n + 1] * ak[n + 1]; |
| 1240 |
3
1. bluestein_real_forward : changed conditional boundary → NO_COVERAGE 2. bluestein_real_forward : Replaced integer division with multiplication → NO_COVERAGE 3. bluestein_real_forward : negated conditional → NO_COVERAGE |
for (int i = 1; i < n / 2; i++) { |
| 1241 |
1
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1242 |
1
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1243 |
4
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2]; |
| 1244 |
5
1. bluestein_real_forward : removed negation → NO_COVERAGE 2. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 5. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1245 | } | |
| 1246 | } else { | |
| 1247 |
3
1. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = bk1[0] * ak[0] + bk1[1] * ak[1]; |
| 1248 |
7
1. bluestein_real_forward : removed negation → NO_COVERAGE 2. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 5. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 6. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 7. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = -bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n]; |
| 1249 |
4
1. bluestein_real_forward : changed conditional boundary → NO_COVERAGE 2. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_forward : Replaced integer division with multiplication → NO_COVERAGE 4. bluestein_real_forward : negated conditional → NO_COVERAGE |
for (int i = 1; i < (n - 1) / 2; i++) { |
| 1250 |
1
1. bluestein_real_forward : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1251 |
1
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1252 |
4
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] + bk1[idx2] * ak[idx2]; |
| 1253 |
5
1. bluestein_real_forward : removed negation → NO_COVERAGE 2. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 5. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = -bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1254 | } | |
| 1255 |
7
1. bluestein_real_forward : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_forward : Replaced integer subtraction with addition → NO_COVERAGE 5. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_forward : Replaced double multiplication with division → NO_COVERAGE 7. bluestein_real_forward : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] + bk1[n] * ak[n]; |
| 1256 | } | |
| 1257 | ||
| 1258 | } | |
| 1259 | ||
| 1260 | private void bluestein_real_inverse(final double[] a, final int offa) { | |
| 1261 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
final double[] ak = new double[2 * nBluestein]; |
| 1262 |
2
1. bluestein_real_inverse : Replaced integer modulus with multiplication → NO_COVERAGE 2. bluestein_real_inverse : negated conditional → NO_COVERAGE |
if (n % 2 == 0) { |
| 1263 |
1
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[0] = a[offa] * bk1[0]; |
| 1264 |
1
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[1] = a[offa] * bk1[1]; |
| 1265 | ||
| 1266 |
3
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer division with multiplication → NO_COVERAGE 3. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = 1; i < n / 2; i++) { |
| 1267 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1268 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1269 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1270 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1271 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2]; |
| 1272 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1]; |
| 1273 | } | |
| 1274 | ||
| 1275 |
2
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[n] = a[offa + 1] * bk1[n]; |
| 1276 |
4
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 4. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[n + 1] = a[offa + 1] * bk1[n + 1]; |
| 1277 | ||
| 1278 |
4
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer division with multiplication → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 4. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = n / 2 + 1; i < n; i++) { |
| 1279 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1280 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1281 |
3
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE |
int idx3 = offa + 2 * n - idx1; |
| 1282 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + 1; |
| 1283 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2]; |
| 1284 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1]; |
| 1285 | } | |
| 1286 | ||
| 1287 | } else { | |
| 1288 |
1
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[0] = a[offa] * bk1[0]; |
| 1289 |
1
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE |
ak[1] = a[offa] * bk1[1]; |
| 1290 | ||
| 1291 |
4
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer division with multiplication → NO_COVERAGE 4. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = 1; i < (n - 1) / 2; i++) { |
| 1292 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1293 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1294 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + idx1; |
| 1295 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = offa + idx2; |
| 1296 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] - a[idx4] * bk1[idx2]; |
| 1297 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2] + a[idx4] * bk1[idx1]; |
| 1298 | } | |
| 1299 | ||
| 1300 |
8
1. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 5. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 7. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 8. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[n - 1] = a[offa + n - 1] * bk1[n - 1] - a[offa + 1] * bk1[n]; |
| 1301 |
7
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 6. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 7. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[n] = a[offa + n - 1] * bk1[n] + a[offa + 1] * bk1[n - 1]; |
| 1302 | ||
| 1303 |
9
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 7. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 8. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 9. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[n + 1] = a[offa + n - 1] * bk1[n + 1] + a[offa + 1] * bk1[n + 2]; |
| 1304 |
9
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 7. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 8. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 9. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[n + 2] = a[offa + n - 1] * bk1[n + 2] - a[offa + 1] * bk1[n + 1]; |
| 1305 | ||
| 1306 |
5
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer division with multiplication → NO_COVERAGE 4. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = (n - 1) / 2 + 2; i < n; i++) { |
| 1307 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1308 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1309 |
3
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 3. bluestein_real_inverse : Replaced integer subtraction with addition → NO_COVERAGE |
int idx3 = offa + 2 * n - idx1; |
| 1310 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + 1; |
| 1311 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1] + a[idx4] * bk1[idx2]; |
| 1312 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2] - a[idx4] * bk1[idx1]; |
| 1313 | } | |
| 1314 | } | |
| 1315 | ||
| 1316 |
2
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1317 | ||
| 1318 | { | |
| 1319 |
2
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1320 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1321 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1322 |
4
1. bluestein_real_inverse : removed negation → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
double im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1323 |
3
1. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2]; |
| 1324 | ak[idx2] = im; | |
| 1325 | } | |
| 1326 | ||
| 1327 |
2
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1328 | ||
| 1329 |
2
1. bluestein_real_inverse : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1330 |
1
1. bluestein_real_inverse : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1331 |
1
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1332 |
4
1. bluestein_real_inverse : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + i] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2]; |
| 1333 | } | |
| 1334 | } | |
| 1335 | } | |
| 1336 | ||
| 1337 | private void bluestein_real_inverse2(final double[] a, final int offa) { | |
| 1338 |
1
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE |
final double[] ak = new double[2 * nBluestein]; |
| 1339 | { | |
| 1340 |
2
1. bluestein_real_inverse2 : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse2 : negated conditional → NO_COVERAGE |
for (int i = 0; i < n; i++) { |
| 1341 |
1
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1342 |
1
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1343 |
1
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = offa + i; |
| 1344 |
1
1. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE |
ak[idx1] = a[idx3] * bk1[idx1]; |
| 1345 |
1
1. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE |
ak[idx2] = a[idx3] * bk1[idx2]; |
| 1346 | } | |
| 1347 | ||
| 1348 |
2
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse2 : removed call to mikera/matrixx/algo/FFT::cftbsub → NO_COVERAGE |
cftbsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1349 | ||
| 1350 |
2
1. bluestein_real_inverse2 : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse2 : negated conditional → NO_COVERAGE |
for (int i = 0; i < nBluestein; i++) { |
| 1351 |
1
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1352 |
1
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1353 |
4
1. bluestein_real_inverse2 : removed negation → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced double addition with subtraction → NO_COVERAGE |
double im = -ak[idx1] * bk2[idx2] + ak[idx2] * bk2[idx1]; |
| 1354 |
3
1. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double addition with subtraction → NO_COVERAGE |
ak[idx1] = ak[idx1] * bk2[idx1] + ak[idx2] * bk2[idx2]; |
| 1355 | ak[idx2] = im; | |
| 1356 | } | |
| 1357 | } | |
| 1358 | ||
| 1359 |
2
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE 2. bluestein_real_inverse2 : removed call to mikera/matrixx/algo/FFT::cftfsub → NO_COVERAGE |
cftfsub(2 * nBluestein, ak, 0, ip, nw, w); |
| 1360 | ||
| 1361 |
2
1. bluestein_real_inverse2 : Replaced integer modulus with multiplication → NO_COVERAGE 2. bluestein_real_inverse2 : negated conditional → NO_COVERAGE |
if (n % 2 == 0) { |
| 1362 |
3
1. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1]; |
| 1363 |
6
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 5. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 1] = bk1[n] * ak[n] - bk1[n + 1] * ak[n + 1]; |
| 1364 |
3
1. bluestein_real_inverse2 : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced integer division with multiplication → NO_COVERAGE 3. bluestein_real_inverse2 : negated conditional → NO_COVERAGE |
for (int i = 1; i < n / 2; i++) { |
| 1365 |
1
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1366 |
1
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1367 |
4
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2]; |
| 1368 |
4
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1369 | } | |
| 1370 | } else { | |
| 1371 |
3
1. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa] = bk1[0] * ak[0] - bk1[1] * ak[1]; |
| 1372 |
6
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 5. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = bk1[n] * ak[n - 1] + bk1[n - 1] * ak[n]; |
| 1373 |
4
1. bluestein_real_inverse2 : changed conditional boundary → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced integer division with multiplication → NO_COVERAGE 4. bluestein_real_inverse2 : negated conditional → NO_COVERAGE |
for (int i = 1; i < (n - 1) / 2; i++) { |
| 1374 |
1
1. bluestein_real_inverse2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = 2 * i; |
| 1375 |
1
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + 1; |
| 1376 |
4
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + idx1] = bk1[idx1] * ak[idx1] - bk1[idx2] * ak[idx2]; |
| 1377 |
4
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + idx2] = bk1[idx2] * ak[idx1] + bk1[idx1] * ak[idx2]; |
| 1378 | } | |
| 1379 |
7
1. bluestein_real_inverse2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 3. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 4. bluestein_real_inverse2 : Replaced integer subtraction with addition → NO_COVERAGE 5. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 6. bluestein_real_inverse2 : Replaced double multiplication with division → NO_COVERAGE 7. bluestein_real_inverse2 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + n - 1] = bk1[n - 1] * ak[n - 1] - bk1[n] * ak[n]; |
| 1380 | } | |
| 1381 | } | |
| 1382 | ||
| 1383 | /*--------------------------------------------------------- | |
| 1384 | rfftf1: further processing of Real forward FFT | |
| 1385 | --------------------------------------------------------*/ | |
| 1386 | void rfftf(final double a[], final int offa) { | |
| 1387 |
1
1. rfftf : negated conditional → KILLED |
if (n == 1) |
| 1388 | return; | |
| 1389 | int l1, l2, na, kh, nf, ip, iw, ido, idl1; | |
| 1390 | ||
| 1391 | final double[] ch = new double[n]; | |
| 1392 |
1
1. rfftf : Replaced integer multiplication with division → KILLED |
final int twon = 2 * n; |
| 1393 |
1
1. rfftf : Replaced integer addition with subtraction → KILLED |
nf = (int) wtable_r[1 + twon]; |
| 1394 | na = 1; | |
| 1395 | l2 = n; | |
| 1396 |
1
1. rfftf : Replaced integer subtraction with addition → SURVIVED |
iw = twon - 1; |
| 1397 |
2
1. rfftf : changed conditional boundary → KILLED 2. rfftf : negated conditional → KILLED |
for (int k1 = 1; k1 <= nf; ++k1) { |
| 1398 |
1
1. rfftf : Replaced integer subtraction with addition → KILLED |
kh = nf - k1; |
| 1399 |
2
1. rfftf : Replaced integer addition with subtraction → KILLED 2. rfftf : Replaced integer addition with subtraction → KILLED |
ip = (int) wtable_r[kh + 2 + twon]; |
| 1400 |
1
1. rfftf : Replaced integer division with multiplication → KILLED |
l1 = l2 / ip; |
| 1401 |
1
1. rfftf : Replaced integer division with multiplication → KILLED |
ido = n / l2; |
| 1402 |
1
1. rfftf : Replaced integer multiplication with division → SURVIVED |
idl1 = ido * l1; |
| 1403 |
3
1. rfftf : Replaced integer subtraction with addition → SURVIVED 2. rfftf : Replaced integer multiplication with division → SURVIVED 3. rfftf : Replaced integer subtraction with addition → SURVIVED |
iw -= (ip - 1) * ido; |
| 1404 |
1
1. rfftf : Replaced integer subtraction with addition → KILLED |
na = 1 - na; |
| 1405 | switch (ip) { | |
| 1406 | case 2: | |
| 1407 |
1
1. rfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1408 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf2 → NO_COVERAGE |
radf2(ido, l1, a, offa, ch, 0, iw); |
| 1409 | } else { | |
| 1410 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf2 → NO_COVERAGE |
radf2(ido, l1, ch, 0, a, offa, iw); |
| 1411 | } | |
| 1412 | break; | |
| 1413 | case 3: | |
| 1414 |
1
1. rfftf : negated conditional → KILLED |
if (na == 0) { |
| 1415 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf3 → KILLED |
radf3(ido, l1, a, offa, ch, 0, iw); |
| 1416 | } else { | |
| 1417 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf3 → NO_COVERAGE |
radf3(ido, l1, ch, 0, a, offa, iw); |
| 1418 | } | |
| 1419 | break; | |
| 1420 | case 4: | |
| 1421 |
1
1. rfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1422 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf4 → NO_COVERAGE |
radf4(ido, l1, a, offa, ch, 0, iw); |
| 1423 | } else { | |
| 1424 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf4 → NO_COVERAGE |
radf4(ido, l1, ch, 0, a, offa, iw); |
| 1425 | } | |
| 1426 | break; | |
| 1427 | case 5: | |
| 1428 |
1
1. rfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1429 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf5 → NO_COVERAGE |
radf5(ido, l1, a, offa, ch, 0, iw); |
| 1430 | } else { | |
| 1431 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radf5 → NO_COVERAGE |
radf5(ido, l1, ch, 0, a, offa, iw); |
| 1432 | } | |
| 1433 | break; | |
| 1434 | default: | |
| 1435 |
1
1. rfftf : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 1436 |
1
1. rfftf : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1437 |
1
1. rfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1438 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radfg → NO_COVERAGE |
radfg(ido, ip, l1, idl1, a, offa, ch, 0, iw); |
| 1439 | na = 1; | |
| 1440 | } else { | |
| 1441 |
1
1. rfftf : removed call to mikera/matrixx/algo/FFT::radfg → NO_COVERAGE |
radfg(ido, ip, l1, idl1, ch, 0, a, offa, iw); |
| 1442 | na = 0; | |
| 1443 | } | |
| 1444 | break; | |
| 1445 | } | |
| 1446 | l2 = l1; | |
| 1447 | } | |
| 1448 |
1
1. rfftf : negated conditional → KILLED |
if (na == 1) |
| 1449 | return; | |
| 1450 |
1
1. rfftf : removed call to java/lang/System::arraycopy → KILLED |
System.arraycopy(ch, 0, a, offa, n); |
| 1451 | } | |
| 1452 | ||
| 1453 | /*--------------------------------------------------------- | |
| 1454 | rfftb1: further processing of Real backward FFT | |
| 1455 | --------------------------------------------------------*/ | |
| 1456 | void rfftb(final double a[], final int offa) { | |
| 1457 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (n == 1) |
| 1458 | return; | |
| 1459 | int l1, l2, na, nf, ip, iw, ido, idl1; | |
| 1460 | ||
| 1461 | double[] ch = new double[n]; | |
| 1462 |
1
1. rfftb : Replaced integer multiplication with division → NO_COVERAGE |
final int twon = 2 * n; |
| 1463 |
1
1. rfftb : Replaced integer addition with subtraction → NO_COVERAGE |
nf = (int) wtable_r[1 + twon]; |
| 1464 | na = 0; | |
| 1465 | l1 = 1; | |
| 1466 | iw = n; | |
| 1467 |
2
1. rfftb : changed conditional boundary → NO_COVERAGE 2. rfftb : negated conditional → NO_COVERAGE |
for (int k1 = 1; k1 <= nf; k1++) { |
| 1468 |
2
1. rfftb : Replaced integer addition with subtraction → NO_COVERAGE 2. rfftb : Replaced integer addition with subtraction → NO_COVERAGE |
ip = (int) wtable_r[k1 + 1 + twon]; |
| 1469 |
1
1. rfftb : Replaced integer multiplication with division → NO_COVERAGE |
l2 = ip * l1; |
| 1470 |
1
1. rfftb : Replaced integer division with multiplication → NO_COVERAGE |
ido = n / l2; |
| 1471 |
1
1. rfftb : Replaced integer multiplication with division → NO_COVERAGE |
idl1 = ido * l1; |
| 1472 | switch (ip) { | |
| 1473 | case 2: | |
| 1474 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1475 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb2 → NO_COVERAGE |
radb2(ido, l1, a, offa, ch, 0, iw); |
| 1476 | } else { | |
| 1477 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb2 → NO_COVERAGE |
radb2(ido, l1, ch, 0, a, offa, iw); |
| 1478 | } | |
| 1479 |
1
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1480 | break; | |
| 1481 | case 3: | |
| 1482 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1483 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb3 → NO_COVERAGE |
radb3(ido, l1, a, offa, ch, 0, iw); |
| 1484 | } else { | |
| 1485 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb3 → NO_COVERAGE |
radb3(ido, l1, ch, 0, a, offa, iw); |
| 1486 | } | |
| 1487 |
1
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1488 | break; | |
| 1489 | case 4: | |
| 1490 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1491 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb4 → NO_COVERAGE |
radb4(ido, l1, a, offa, ch, 0, iw); |
| 1492 | } else { | |
| 1493 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb4 → NO_COVERAGE |
radb4(ido, l1, ch, 0, a, offa, iw); |
| 1494 | } | |
| 1495 |
1
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1496 | break; | |
| 1497 | case 5: | |
| 1498 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1499 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb5 → NO_COVERAGE |
radb5(ido, l1, a, offa, ch, 0, iw); |
| 1500 | } else { | |
| 1501 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radb5 → NO_COVERAGE |
radb5(ido, l1, ch, 0, a, offa, iw); |
| 1502 | } | |
| 1503 |
1
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1504 | break; | |
| 1505 | default: | |
| 1506 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 1507 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radbg → NO_COVERAGE |
radbg(ido, ip, l1, idl1, a, offa, ch, 0, iw); |
| 1508 | } else { | |
| 1509 |
1
1. rfftb : removed call to mikera/matrixx/algo/FFT::radbg → NO_COVERAGE |
radbg(ido, ip, l1, idl1, ch, 0, a, offa, iw); |
| 1510 | } | |
| 1511 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 1512 |
1
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 1513 | break; | |
| 1514 | } | |
| 1515 | l1 = l2; | |
| 1516 |
3
1. rfftb : Replaced integer subtraction with addition → NO_COVERAGE 2. rfftb : Replaced integer multiplication with division → NO_COVERAGE 3. rfftb : Replaced integer addition with subtraction → NO_COVERAGE |
iw += (ip - 1) * ido; |
| 1517 | } | |
| 1518 |
1
1. rfftb : negated conditional → NO_COVERAGE |
if (na == 0) |
| 1519 | return; | |
| 1520 |
1
1. rfftb : removed call to java/lang/System::arraycopy → NO_COVERAGE |
System.arraycopy(ch, 0, a, offa, n); |
| 1521 | } | |
| 1522 | ||
| 1523 | /*------------------------------------------------- | |
| 1524 | radf2: Real FFT's forward processing of factor 2 | |
| 1525 | -------------------------------------------------*/ | |
| 1526 | void radf2(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1527 | int i, ic, idx0, idx1, idx2, idx3, idx4; | |
| 1528 | double t1i, t1r, w1r, w1i; | |
| 1529 | int iw1; | |
| 1530 | iw1 = offset; | |
| 1531 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx0 = l1 * ido; |
| 1532 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx1 = 2 * ido; |
| 1533 |
2
1. radf2 : changed conditional boundary → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1534 |
2
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + k * idx1; |
| 1535 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
int oidx2 = oidx1 + idx1 - 1; |
| 1536 |
2
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + k * ido; |
| 1537 |
1
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + idx0; |
| 1538 | ||
| 1539 | double i1r = in[iidx1]; | |
| 1540 | double i2r = in[iidx2]; | |
| 1541 | ||
| 1542 |
1
1. radf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2r; |
| 1543 |
1
1. radf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = i1r - i2r; |
| 1544 | } | |
| 1545 |
2
1. radf2 : changed conditional boundary → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
if (ido < 2) |
| 1546 | return; | |
| 1547 |
1
1. radf2 : negated conditional → NO_COVERAGE |
if (ido != 2) { |
| 1548 |
2
1. radf2 : changed conditional boundary → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1549 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx1 = k * ido; |
| 1550 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx2 = 2 * idx1; |
| 1551 |
1
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = idx2 + ido; |
| 1552 |
1
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx4 = idx1 + idx0; |
| 1553 |
2
1. radf2 : changed conditional boundary → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 1554 |
1
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 1555 |
2
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 1556 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i + idx2; |
| 1557 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = out_off + ic + idx3; |
| 1558 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + i + idx1; |
| 1559 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = in_off + i + idx4; |
| 1560 | ||
| 1561 |
1
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
double a1i = in[iidx1 - 1]; |
| 1562 | double a1r = in[iidx1]; | |
| 1563 |
1
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
double a2i = in[iidx2 - 1]; |
| 1564 | double a2r = in[iidx2]; | |
| 1565 | ||
| 1566 |
1
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 1567 | w1i = wtable_r[widx1]; | |
| 1568 | ||
| 1569 |
3
1. radf2 : Replaced double multiplication with division → NO_COVERAGE 2. radf2 : Replaced double multiplication with division → NO_COVERAGE 3. radf2 : Replaced double addition with subtraction → NO_COVERAGE |
t1r = w1r * a2i + w1i * a2r; |
| 1570 |
3
1. radf2 : Replaced double multiplication with division → NO_COVERAGE 2. radf2 : Replaced double multiplication with division → NO_COVERAGE 3. radf2 : Replaced double subtraction with addition → NO_COVERAGE |
t1i = w1r * a2r - w1i * a2i; |
| 1571 | ||
| 1572 |
1
1. radf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = a1r + t1i; |
| 1573 |
2
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = a1i + t1r; |
| 1574 | ||
| 1575 |
1
1. radf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = t1i - a1r; |
| 1576 |
2
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = a1i - t1r; |
| 1577 | } | |
| 1578 | } | |
| 1579 |
2
1. radf2 : Replaced integer modulus with multiplication → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
if (ido % 2 == 1) |
| 1580 | return; | |
| 1581 | } | |
| 1582 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx2 = 2 * idx1; |
| 1583 |
2
1. radf2 : changed conditional boundary → NO_COVERAGE 2. radf2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1584 |
1
1. radf2 : Replaced integer multiplication with division → NO_COVERAGE |
idx1 = k * ido; |
| 1585 |
2
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx2 + ido; |
| 1586 |
3
1. radf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf2 : Replaced integer subtraction with addition → NO_COVERAGE 3. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + ido - 1 + idx1; |
| 1587 | ||
| 1588 |
2
1. radf2 : removed negation → NO_COVERAGE 2. radf2 : Replaced integer addition with subtraction → NO_COVERAGE |
out[oidx1] = -in[iidx1 + idx0]; |
| 1589 |
1
1. radf2 : Replaced integer subtraction with addition → NO_COVERAGE |
out[oidx1 - 1] = in[iidx1]; |
| 1590 | } | |
| 1591 | } | |
| 1592 | ||
| 1593 | /*------------------------------------------------- | |
| 1594 | radb2: Real FFT's backward processing of factor 2 | |
| 1595 | -------------------------------------------------*/ | |
| 1596 | void radb2(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1597 | int i, ic; | |
| 1598 | double t1i, t1r, w1r, w1i; | |
| 1599 | int iw1 = offset; | |
| 1600 | ||
| 1601 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 1602 |
2
1. radb2 : changed conditional boundary → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1603 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1604 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 2 * idx1; |
| 1605 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 1606 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx1; |
| 1607 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + idx2; |
| 1608 |
3
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 3. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = in_off + ido - 1 + idx3; |
| 1609 | double i1r = in[iidx1]; | |
| 1610 | double i2r = in[iidx2]; | |
| 1611 |
1
1. radb2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2r; |
| 1612 |
2
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 + idx0] = i1r - i2r; |
| 1613 | } | |
| 1614 |
2
1. radb2 : changed conditional boundary → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
if (ido < 2) |
| 1615 | return; | |
| 1616 |
1
1. radb2 : negated conditional → NO_COVERAGE |
if (ido != 2) { |
| 1617 |
2
1. radb2 : changed conditional boundary → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; ++k) { |
| 1618 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1619 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 2 * idx1; |
| 1620 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 1621 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx1 + idx0; |
| 1622 |
2
1. radb2 : changed conditional boundary → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 1623 |
1
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 1624 |
2
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = i - 1 + iw1; |
| 1625 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = out_off + i; |
| 1626 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = in_off + i; |
| 1627 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = in_off + ic; |
| 1628 |
1
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[idx5 - 1]; |
| 1629 | w1i = wtable_r[idx5]; | |
| 1630 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx7 + idx2; |
| 1631 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx8 + idx3; |
| 1632 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx6 + idx1; |
| 1633 |
1
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx6 + idx4; |
| 1634 |
3
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 3. radb2 : Replaced double subtraction with addition → NO_COVERAGE |
t1r = in[iidx1 - 1] - in[iidx2 - 1]; |
| 1635 |
1
1. radb2 : Replaced double addition with subtraction → NO_COVERAGE |
t1i = in[iidx1] + in[iidx2]; |
| 1636 | double i1i = in[iidx1]; | |
| 1637 |
1
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1r = in[iidx1 - 1]; |
| 1638 | double i2i = in[iidx2]; | |
| 1639 |
1
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2r = in[iidx2 - 1]; |
| 1640 | ||
| 1641 |
2
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = i1r + i2r; |
| 1642 |
1
1. radb2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1] = i1i - i2i; |
| 1643 |
4
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb2 : Replaced double multiplication with division → NO_COVERAGE 3. radb2 : Replaced double multiplication with division → NO_COVERAGE 4. radb2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = w1r * t1r - w1i * t1i; |
| 1644 |
3
1. radb2 : Replaced double multiplication with division → NO_COVERAGE 2. radb2 : Replaced double multiplication with division → NO_COVERAGE 3. radb2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = w1r * t1i + w1i * t1r; |
| 1645 | } | |
| 1646 | } | |
| 1647 |
2
1. radb2 : Replaced integer modulus with multiplication → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
if (ido % 2 == 1) |
| 1648 | return; | |
| 1649 | } | |
| 1650 |
2
1. radb2 : changed conditional boundary → NO_COVERAGE 2. radb2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1651 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1652 |
1
1. radb2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 2 * idx1; |
| 1653 |
3
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 3. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + ido - 1 + idx1; |
| 1654 |
2
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + idx2 + ido; |
| 1655 |
2
1. radb2 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb2 : Replaced double multiplication with division → NO_COVERAGE |
out[oidx1] = 2 * in[iidx1 - 1]; |
| 1656 |
2
1. radb2 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb2 : Replaced double multiplication with division → NO_COVERAGE |
out[oidx1 + idx0] = -2 * in[iidx1]; |
| 1657 | } | |
| 1658 | } | |
| 1659 | ||
| 1660 | /*------------------------------------------------- | |
| 1661 | radf3: Real FFT's forward processing of factor 3 | |
| 1662 | -------------------------------------------------*/ | |
| 1663 | void radf3(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1664 | final double taur = -0.5; | |
| 1665 | final double taui = 0.866025403784438707610604524234076962; | |
| 1666 | int i, ic; | |
| 1667 | double ci2, di2, di3, cr2, dr2, dr3, ti2, ti3, tr2, tr3, w1r, w2r, w1i, w2i; | |
| 1668 | int iw1, iw2; | |
| 1669 | iw1 = offset; | |
| 1670 |
1
1. radf3 : Replaced integer addition with subtraction → SURVIVED |
iw2 = iw1 + ido; |
| 1671 | ||
| 1672 |
1
1. radf3 : Replaced integer multiplication with division → SURVIVED |
int idx0 = l1 * ido; |
| 1673 |
2
1. radf3 : changed conditional boundary → KILLED 2. radf3 : negated conditional → KILLED |
for (int k = 0; k < l1; k++) { |
| 1674 |
1
1. radf3 : Replaced integer multiplication with division → SURVIVED |
int idx1 = k * ido; |
| 1675 |
1
1. radf3 : Replaced integer multiplication with division → SURVIVED |
int idx3 = 2 * idx0; |
| 1676 |
3
1. radf3 : Replaced integer multiplication with division → SURVIVED 2. radf3 : Replaced integer multiplication with division → KILLED 3. radf3 : Replaced integer addition with subtraction → KILLED |
int idx4 = (3 * k + 1) * ido; |
| 1677 |
1
1. radf3 : Replaced integer addition with subtraction → SURVIVED |
int iidx1 = in_off + idx1; |
| 1678 |
1
1. radf3 : Replaced integer addition with subtraction → KILLED |
int iidx2 = iidx1 + idx0; |
| 1679 |
1
1. radf3 : Replaced integer addition with subtraction → KILLED |
int iidx3 = iidx1 + idx3; |
| 1680 | double i1r = in[iidx1]; | |
| 1681 | double i2r = in[iidx2]; | |
| 1682 | double i3r = in[iidx3]; | |
| 1683 |
1
1. radf3 : Replaced double addition with subtraction → KILLED |
cr2 = i2r + i3r; |
| 1684 |
3
1. radf3 : Replaced integer addition with subtraction → SURVIVED 2. radf3 : Replaced integer multiplication with division → KILLED 3. radf3 : Replaced double addition with subtraction → KILLED |
out[out_off + 3 * idx1] = i1r + cr2; |
| 1685 |
4
1. radf3 : Replaced integer addition with subtraction → KILLED 2. radf3 : Replaced integer addition with subtraction → KILLED 3. radf3 : Replaced double subtraction with addition → KILLED 4. radf3 : Replaced double multiplication with division → KILLED |
out[out_off + idx4 + ido] = taui * (i3r - i2r); |
| 1686 |
5
1. radf3 : Replaced integer addition with subtraction → KILLED 2. radf3 : Replaced integer subtraction with addition → KILLED 3. radf3 : Replaced integer addition with subtraction → KILLED 4. radf3 : Replaced double multiplication with division → KILLED 5. radf3 : Replaced double addition with subtraction → KILLED |
out[out_off + ido - 1 + idx4] = i1r + taur * cr2; |
| 1687 | } | |
| 1688 |
1
1. radf3 : negated conditional → SURVIVED |
if (ido == 1) |
| 1689 | return; | |
| 1690 |
2
1. radf3 : changed conditional boundary → NO_COVERAGE 2. radf3 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1691 |
1
1. radf3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = k * ido; |
| 1692 |
1
1. radf3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = 3 * idx3; |
| 1693 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx3 + idx0; |
| 1694 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + idx0; |
| 1695 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx4 + ido; |
| 1696 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 1697 |
2
1. radf3 : changed conditional boundary → NO_COVERAGE 2. radf3 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 1698 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 1699 |
2
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 1700 |
2
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 1701 | ||
| 1702 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 1703 | w1i = wtable_r[widx1]; | |
| 1704 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 1705 | w2i = wtable_r[widx2]; | |
| 1706 | ||
| 1707 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + i; |
| 1708 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = out_off + i; |
| 1709 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx11 = out_off + ic; |
| 1710 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx9 + idx3; |
| 1711 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx9 + idx5; |
| 1712 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx9 + idx6; |
| 1713 | ||
| 1714 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 1715 | double i1r = in[iidx1]; | |
| 1716 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 1717 | double i2r = in[iidx2]; | |
| 1718 |
1
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 1719 | double i3r = in[iidx3]; | |
| 1720 | ||
| 1721 |
3
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE 3. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
dr2 = w1r * i2i + w1i * i2r; |
| 1722 |
3
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE 3. radf3 : Replaced double subtraction with addition → NO_COVERAGE |
di2 = w1r * i2r - w1i * i2i; |
| 1723 |
3
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE 3. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
dr3 = w2r * i3i + w2i * i3r; |
| 1724 |
3
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE 3. radf3 : Replaced double subtraction with addition → NO_COVERAGE |
di3 = w2r * i3r - w2i * i3i; |
| 1725 |
1
1. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = dr2 + dr3; |
| 1726 |
1
1. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = di2 + di3; |
| 1727 |
2
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + taur * cr2; |
| 1728 |
2
1. radf3 : Replaced double multiplication with division → NO_COVERAGE 2. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + taur * ci2; |
| 1729 |
2
1. radf3 : Replaced double subtraction with addition → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE |
tr3 = taui * (di2 - di3); |
| 1730 |
2
1. radf3 : Replaced double subtraction with addition → NO_COVERAGE 2. radf3 : Replaced double multiplication with division → NO_COVERAGE |
ti3 = taui * (dr3 - dr2); |
| 1731 | ||
| 1732 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx10 + idx4; |
| 1733 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx11 + idx7; |
| 1734 |
1
1. radf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx10 + idx8; |
| 1735 | ||
| 1736 |
2
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = i1i + cr2; |
| 1737 |
1
1. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + ci2; |
| 1738 |
2
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = tr2 - tr3; |
| 1739 |
1
1. radf3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = ti3 - ti2; |
| 1740 |
2
1. radf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 - 1] = tr2 + tr3; |
| 1741 |
1
1. radf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = ti2 + ti3; |
| 1742 | } | |
| 1743 | } | |
| 1744 | } | |
| 1745 | ||
| 1746 | /*------------------------------------------------- | |
| 1747 | radb3: Real FFT's backward processing of factor 3 | |
| 1748 | -------------------------------------------------*/ | |
| 1749 | void radb3(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1750 | final double taur = -0.5; | |
| 1751 | final double taui = 0.866025403784438707610604524234076962; | |
| 1752 | int i, ic; | |
| 1753 | double ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2, w1r, w2r, w1i, w2i; | |
| 1754 | int iw1, iw2; | |
| 1755 | iw1 = offset; | |
| 1756 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 1757 | ||
| 1758 |
2
1. radb3 : changed conditional boundary → NO_COVERAGE 2. radb3 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1759 |
1
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1760 |
2
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE 2. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + 3 * idx1; |
| 1761 |
2
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE 2. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + 2 * ido; |
| 1762 | double i1i = in[iidx1]; | |
| 1763 | ||
| 1764 |
2
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE |
tr2 = 2 * in[iidx2 - 1]; |
| 1765 |
2
1. radb3 : Replaced double multiplication with division → NO_COVERAGE 2. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i1i + taur * tr2; |
| 1766 |
1
1. radb3 : Replaced double multiplication with division → NO_COVERAGE |
ci3 = 2 * taui * in[iidx2]; |
| 1767 | ||
| 1768 |
2
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx1] = i1i + tr2; |
| 1769 |
4
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb3 : Replaced integer multiplication with division → NO_COVERAGE 3. radb3 : Replaced integer addition with subtraction → NO_COVERAGE 4. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + (k + l1) * ido] = cr2 - ci3; |
| 1770 |
5
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE 2. radb3 : Replaced integer addition with subtraction → NO_COVERAGE 3. radb3 : Replaced integer multiplication with division → NO_COVERAGE 4. radb3 : Replaced integer addition with subtraction → NO_COVERAGE 5. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + (k + 2 * l1) * ido] = cr2 + ci3; |
| 1771 | } | |
| 1772 |
1
1. radb3 : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 1773 | return; | |
| 1774 |
1
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 1775 |
2
1. radb3 : changed conditional boundary → NO_COVERAGE 2. radb3 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1776 |
1
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1777 |
1
1. radb3 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 3 * idx1; |
| 1778 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 1779 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + ido; |
| 1780 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx1 + idx0; |
| 1781 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + idx0; |
| 1782 |
2
1. radb3 : changed conditional boundary → NO_COVERAGE 2. radb3 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 1783 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 1784 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = in_off + i; |
| 1785 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = in_off + ic; |
| 1786 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = out_off + i; |
| 1787 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx7 + idx2; |
| 1788 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx7 + idx4; |
| 1789 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx8 + idx3; |
| 1790 | ||
| 1791 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 1792 | double i1r = in[iidx1]; | |
| 1793 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 1794 | double i2r = in[iidx2]; | |
| 1795 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 1796 | double i3r = in[iidx3]; | |
| 1797 | ||
| 1798 |
1
1. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i2i + i3i; |
| 1799 |
2
1. radb3 : Replaced double multiplication with division → NO_COVERAGE 2. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i1i + taur * tr2; |
| 1800 |
1
1. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
ti2 = i2r - i3r; |
| 1801 |
2
1. radb3 : Replaced double multiplication with division → NO_COVERAGE 2. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = i1r + taur * ti2; |
| 1802 |
2
1. radb3 : Replaced double subtraction with addition → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE |
cr3 = taui * (i2i - i3i); |
| 1803 |
2
1. radb3 : Replaced double addition with subtraction → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE |
ci3 = taui * (i2r + i3r); |
| 1804 |
1
1. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
dr2 = cr2 - ci3; |
| 1805 |
1
1. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
dr3 = cr2 + ci3; |
| 1806 |
1
1. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
di2 = ci2 + cr3; |
| 1807 |
1
1. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
di3 = ci2 - cr3; |
| 1808 | ||
| 1809 |
2
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 1810 |
2
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 1811 | ||
| 1812 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 1813 | w1i = wtable_r[widx1]; | |
| 1814 |
1
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 1815 | w2i = wtable_r[widx2]; | |
| 1816 | ||
| 1817 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx9 + idx1; |
| 1818 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx9 + idx5; |
| 1819 |
1
1. radb3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx9 + idx6; |
| 1820 | ||
| 1821 |
2
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = i1i + tr2; |
| 1822 |
1
1. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + ti2; |
| 1823 |
4
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE 3. radb3 : Replaced double multiplication with division → NO_COVERAGE 4. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = w1r * dr2 - w1i * di2; |
| 1824 |
3
1. radb3 : Replaced double multiplication with division → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE 3. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = w1r * di2 + w1i * dr2; |
| 1825 |
4
1. radb3 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE 3. radb3 : Replaced double multiplication with division → NO_COVERAGE 4. radb3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3 - 1] = w2r * dr3 - w2i * di3; |
| 1826 |
3
1. radb3 : Replaced double multiplication with division → NO_COVERAGE 2. radb3 : Replaced double multiplication with division → NO_COVERAGE 3. radb3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = w2r * di3 + w2i * dr3; |
| 1827 | } | |
| 1828 | } | |
| 1829 | } | |
| 1830 | ||
| 1831 | /*------------------------------------------------- | |
| 1832 | radf4: Real FFT's forward processing of factor 4 | |
| 1833 | -------------------------------------------------*/ | |
| 1834 | void radf4(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1835 | final double hsqt2 = 0.707106781186547572737310929369414225; | |
| 1836 | int i, ic; | |
| 1837 | double ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i; | |
| 1838 | int iw1, iw2, iw3; | |
| 1839 | iw1 = offset; | |
| 1840 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = offset + ido; |
| 1841 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 1842 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 1843 |
2
1. radf4 : changed conditional boundary → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1844 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1845 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 4 * idx1; |
| 1846 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx1 + idx0; |
| 1847 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 1848 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + idx0; |
| 1849 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx2 + ido; |
| 1850 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[in_off + idx1]; |
| 1851 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[in_off + idx3]; |
| 1852 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i3r = in[in_off + idx4]; |
| 1853 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i4r = in[in_off + idx5]; |
| 1854 | ||
| 1855 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr1 = i2r + i4r; |
| 1856 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1r + i3r; |
| 1857 | ||
| 1858 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx2; |
| 1859 |
2
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = out_off + idx6 + ido; |
| 1860 | ||
| 1861 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = tr1 + tr2; |
| 1862 |
4
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 4. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1 + ido + ido] = tr2 - tr1; |
| 1863 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = i1r - i3r; |
| 1864 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = i4r - i2r; |
| 1865 | } | |
| 1866 |
2
1. radf4 : changed conditional boundary → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
if (ido < 2) |
| 1867 | return; | |
| 1868 |
1
1. radf4 : negated conditional → NO_COVERAGE |
if (ido != 2) { |
| 1869 |
2
1. radf4 : changed conditional boundary → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1870 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1871 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + idx0; |
| 1872 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + idx0; |
| 1873 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 1874 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = 4 * idx1; |
| 1875 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 1876 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx6 + ido; |
| 1877 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 1878 |
2
1. radf4 : changed conditional boundary → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 1879 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 1880 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 1881 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 1882 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i - 1 + iw3; |
| 1883 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 1884 | w1i = wtable_r[widx1]; | |
| 1885 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 1886 | w2i = wtable_r[widx2]; | |
| 1887 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
w3r = wtable_r[widx3 - 1]; |
| 1888 | w3i = wtable_r[widx3]; | |
| 1889 | ||
| 1890 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + i; |
| 1891 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = out_off + i; |
| 1892 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx11 = out_off + ic; |
| 1893 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx9 + idx1; |
| 1894 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx9 + idx2; |
| 1895 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx9 + idx3; |
| 1896 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = idx9 + idx4; |
| 1897 | ||
| 1898 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 1899 | double i1r = in[iidx1]; | |
| 1900 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 1901 | double i2r = in[iidx2]; | |
| 1902 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 1903 | double i3r = in[iidx3]; | |
| 1904 |
1
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 1905 | double i4r = in[iidx4]; | |
| 1906 | ||
| 1907 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = w1r * i2i + w1i * i2r; |
| 1908 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
ci2 = w1r * i2r - w1i * i2i; |
| 1909 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = w2r * i3i + w2i * i3r; |
| 1910 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
ci3 = w2r * i3r - w2i * i3i; |
| 1911 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
cr4 = w3r * i4i + w3i * i4r; |
| 1912 |
3
1. radf4 : Replaced double multiplication with division → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE 3. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = w3r * i4r - w3i * i4i; |
| 1913 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr1 = cr2 + cr4; |
| 1914 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = cr4 - cr2; |
| 1915 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti1 = ci2 + ci4; |
| 1916 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = ci2 - ci4; |
| 1917 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + ci3; |
| 1918 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti3 = i1r - ci3; |
| 1919 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + cr3; |
| 1920 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr3 = i1i - cr3; |
| 1921 | ||
| 1922 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx10 + idx5; |
| 1923 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx11 + idx6; |
| 1924 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx10 + idx7; |
| 1925 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = idx11 + idx8; |
| 1926 | ||
| 1927 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = tr1 + tr2; |
| 1928 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 - 1] = tr2 - tr1; |
| 1929 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = ti1 + ti2; |
| 1930 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4] = ti1 - ti2; |
| 1931 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 - 1] = ti4 + tr3; |
| 1932 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = tr3 - ti4; |
| 1933 |
1
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = tr4 + ti3; |
| 1934 |
1
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = tr4 - ti3; |
| 1935 | } | |
| 1936 | } | |
| 1937 |
2
1. radf4 : Replaced integer modulus with multiplication → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
if (ido % 2 == 1) |
| 1938 | return; | |
| 1939 | } | |
| 1940 |
2
1. radf4 : changed conditional boundary → NO_COVERAGE 2. radf4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1941 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1942 |
1
1. radf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 4 * idx1; |
| 1943 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx1 + idx0; |
| 1944 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 1945 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + idx0; |
| 1946 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx2 + ido; |
| 1947 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx6 + ido; |
| 1948 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 1949 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + ido; |
| 1950 |
1
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = out_off + ido; |
| 1951 | ||
| 1952 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1i = in[idx9 - 1 + idx1]; |
| 1953 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2i = in[idx9 - 1 + idx3]; |
| 1954 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i3i = in[idx9 - 1 + idx4]; |
| 1955 |
2
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i4i = in[idx9 - 1 + idx5]; |
| 1956 | ||
| 1957 |
2
1. radf4 : Replaced double addition with subtraction → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE |
ti1 = -hsqt2 * (i2i + i4i); |
| 1958 |
2
1. radf4 : Replaced double subtraction with addition → NO_COVERAGE 2. radf4 : Replaced double multiplication with division → NO_COVERAGE |
tr1 = hsqt2 * (i2i - i4i); |
| 1959 | ||
| 1960 |
3
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[idx10 - 1 + idx2] = tr1 + i1i; |
| 1961 |
3
1. radf4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[idx10 - 1 + idx7] = i1i - tr1; |
| 1962 |
2
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx6] = ti1 - i3i; |
| 1963 |
2
1. radf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx8] = ti1 + i3i; |
| 1964 | } | |
| 1965 | } | |
| 1966 | ||
| 1967 | /*------------------------------------------------- | |
| 1968 | radb4: Real FFT's backward processing of factor 4 | |
| 1969 | -------------------------------------------------*/ | |
| 1970 | void radb4(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 1971 | final double sqrt2 = 1.41421356237309514547462185873882845; | |
| 1972 | int i, ic; | |
| 1973 | double ci2, ci3, ci4, cr2, cr3, cr4; | |
| 1974 | double ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4, w1r, w1i, w2r, w2i, w3r, w3i; | |
| 1975 | int iw1, iw2, iw3; | |
| 1976 | iw1 = offset; | |
| 1977 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 1978 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 1979 | ||
| 1980 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 1981 |
2
1. radb4 : changed conditional boundary → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 1982 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 1983 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 4 * idx1; |
| 1984 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx1 + idx0; |
| 1985 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 1986 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + idx0; |
| 1987 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx2 + ido; |
| 1988 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx6 + ido; |
| 1989 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 1990 | ||
| 1991 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[in_off + idx2]; |
| 1992 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[in_off + idx7]; |
| 1993 |
3
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 3. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i3r = in[in_off + ido - 1 + idx8]; |
| 1994 |
3
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 3. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i4r = in[in_off + ido - 1 + idx6]; |
| 1995 | ||
| 1996 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
tr1 = i1r - i3r; |
| 1997 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1r + i3r; |
| 1998 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i4r + i4r; |
| 1999 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr4 = i2r + i2r; |
| 2000 | ||
| 2001 |
2
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx1] = tr2 + tr3; |
| 2002 |
2
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx3] = tr1 - tr4; |
| 2003 |
2
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx4] = tr2 - tr3; |
| 2004 |
2
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx5] = tr1 + tr4; |
| 2005 | } | |
| 2006 |
2
1. radb4 : changed conditional boundary → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
if (ido < 2) |
| 2007 | return; | |
| 2008 |
1
1. radb4 : negated conditional → NO_COVERAGE |
if (ido != 2) { |
| 2009 |
2
1. radb4 : changed conditional boundary → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; ++k) { |
| 2010 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2011 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idx1 + idx0; |
| 2012 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + idx0; |
| 2013 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 2014 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = 4 * idx1; |
| 2015 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 2016 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx6 + ido; |
| 2017 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 2018 |
2
1. radb4 : changed conditional boundary → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 2019 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2020 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 2021 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 2022 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i - 1 + iw3; |
| 2023 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 2024 | w1i = wtable_r[widx1]; | |
| 2025 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 2026 | w2i = wtable_r[widx2]; | |
| 2027 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
w3r = wtable_r[widx3 - 1]; |
| 2028 | w3i = wtable_r[widx3]; | |
| 2029 | ||
| 2030 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx12 = in_off + i; |
| 2031 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx13 = in_off + ic; |
| 2032 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx14 = out_off + i; |
| 2033 | ||
| 2034 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx12 + idx5; |
| 2035 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx13 + idx6; |
| 2036 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx12 + idx7; |
| 2037 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = idx13 + idx8; |
| 2038 | ||
| 2039 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2040 | double i1r = in[iidx1]; | |
| 2041 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 2042 | double i2r = in[iidx2]; | |
| 2043 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 2044 | double i3r = in[iidx3]; | |
| 2045 |
1
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 2046 | double i4r = in[iidx4]; | |
| 2047 | ||
| 2048 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
ti1 = i1r + i4r; |
| 2049 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ti2 = i1r - i4r; |
| 2050 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ti3 = i3r - i2r; |
| 2051 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr4 = i3r + i2r; |
| 2052 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
tr1 = i1i - i4i; |
| 2053 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + i4i; |
| 2054 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = i3i - i2i; |
| 2055 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i3i + i2i; |
| 2056 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
cr3 = tr2 - tr3; |
| 2057 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ci3 = ti2 - ti3; |
| 2058 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
cr2 = tr1 - tr4; |
| 2059 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
cr4 = tr1 + tr4; |
| 2060 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = ti1 + ti4; |
| 2061 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = ti1 - ti4; |
| 2062 | ||
| 2063 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx14 + idx1; |
| 2064 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx14 + idx2; |
| 2065 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx14 + idx3; |
| 2066 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = idx14 + idx4; |
| 2067 | ||
| 2068 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = tr2 + tr3; |
| 2069 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = ti2 + ti3; |
| 2070 |
4
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double multiplication with division → NO_COVERAGE 4. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = w1r * cr2 - w1i * ci2; |
| 2071 |
3
1. radb4 : Replaced double multiplication with division → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = w1r * ci2 + w1i * cr2; |
| 2072 |
4
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double multiplication with division → NO_COVERAGE 4. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3 - 1] = w2r * cr3 - w2i * ci3; |
| 2073 |
3
1. radb4 : Replaced double multiplication with division → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = w2r * ci3 + w2i * cr3; |
| 2074 |
4
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double multiplication with division → NO_COVERAGE 4. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 - 1] = w3r * cr4 - w3i * ci4; |
| 2075 |
3
1. radb4 : Replaced double multiplication with division → NO_COVERAGE 2. radb4 : Replaced double multiplication with division → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx4] = w3r * ci4 + w3i * cr4; |
| 2076 | } | |
| 2077 | } | |
| 2078 |
2
1. radb4 : Replaced integer modulus with multiplication → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
if (ido % 2 == 1) |
| 2079 | return; | |
| 2080 | } | |
| 2081 |
2
1. radb4 : changed conditional boundary → NO_COVERAGE 2. radb4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2082 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2083 |
1
1. radb4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 4 * idx1; |
| 2084 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx1 + idx0; |
| 2085 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx0; |
| 2086 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + idx0; |
| 2087 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx2 + ido; |
| 2088 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx6 + ido; |
| 2089 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + ido; |
| 2090 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + ido; |
| 2091 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = out_off + ido; |
| 2092 | ||
| 2093 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[idx9 - 1 + idx2]; |
| 2094 |
2
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[idx9 - 1 + idx7]; |
| 2095 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i3r = in[in_off + idx6]; |
| 2096 |
1
1. radb4 : Replaced integer addition with subtraction → NO_COVERAGE |
double i4r = in[in_off + idx8]; |
| 2097 | ||
| 2098 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
ti1 = i3r + i4r; |
| 2099 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
ti2 = i4r - i3r; |
| 2100 |
1
1. radb4 : Replaced double subtraction with addition → NO_COVERAGE |
tr1 = i1r - i2r; |
| 2101 |
1
1. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1r + i2r; |
| 2102 | ||
| 2103 |
3
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[idx10 - 1 + idx1] = tr2 + tr2; |
| 2104 |
4
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radb4 : Replaced double subtraction with addition → NO_COVERAGE 4. radb4 : Replaced double multiplication with division → NO_COVERAGE |
out[idx10 - 1 + idx3] = sqrt2 * (tr1 - ti1); |
| 2105 |
3
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE |
out[idx10 - 1 + idx4] = ti2 + ti2; |
| 2106 |
4
1. radb4 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb4 : Replaced integer addition with subtraction → NO_COVERAGE 3. radb4 : Replaced double addition with subtraction → NO_COVERAGE 4. radb4 : Replaced double multiplication with division → NO_COVERAGE |
out[idx10 - 1 + idx5] = -sqrt2 * (tr1 + ti1); |
| 2107 | } | |
| 2108 | } | |
| 2109 | ||
| 2110 | /*------------------------------------------------- | |
| 2111 | radf5: Real FFT's forward processing of factor 5 | |
| 2112 | -------------------------------------------------*/ | |
| 2113 | void radf5(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 2114 | final double tr11 = 0.309016994374947451262869435595348477; | |
| 2115 | final double ti11 = 0.951056516295153531181938433292089030; | |
| 2116 | final double tr12 = -0.809016994374947340240566973079694435; | |
| 2117 | final double ti12 = 0.587785252292473248125759255344746634; | |
| 2118 | int i, ic; | |
| 2119 | double ci2, di2, ci4, ci5, di3, di4, di5, ci3, cr2, cr3, dr2, dr3, dr4, dr5, cr5, cr4, ti2, ti3, ti5, ti4, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i; | |
| 2120 | int iw1, iw2, iw3, iw4; | |
| 2121 | iw1 = offset; | |
| 2122 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 2123 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 2124 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw4 = iw3 + ido; |
| 2125 | ||
| 2126 |
1
1. radf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 2127 |
2
1. radf5 : changed conditional boundary → NO_COVERAGE 2. radf5 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2128 |
1
1. radf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2129 |
1
1. radf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 5 * idx1; |
| 2130 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 2131 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + ido; |
| 2132 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + ido; |
| 2133 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 2134 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx1 + idx0; |
| 2135 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + idx0; |
| 2136 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = idx8 + idx0; |
| 2137 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = idx9 + idx0; |
| 2138 |
2
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
int idx11 = out_off + ido - 1; |
| 2139 | ||
| 2140 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[in_off + idx1]; |
| 2141 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[in_off + idx7]; |
| 2142 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i3r = in[in_off + idx8]; |
| 2143 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i4r = in[in_off + idx9]; |
| 2144 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i5r = in[in_off + idx10]; |
| 2145 | ||
| 2146 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i5r + i2r; |
| 2147 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
ci5 = i5r - i2r; |
| 2148 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = i4r + i3r; |
| 2149 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = i4r - i3r; |
| 2150 | ||
| 2151 |
3
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx2] = i1r + cr2 + cr3; |
| 2152 |
5
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE 4. radf5 : Replaced double multiplication with division → NO_COVERAGE 5. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[idx11 + idx3] = i1r + tr11 * cr2 + tr12 * cr3; |
| 2153 |
4
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx4] = ti11 * ci5 + ti12 * ci4; |
| 2154 |
5
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE 4. radf5 : Replaced double multiplication with division → NO_COVERAGE 5. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[idx11 + idx5] = i1r + tr12 * cr2 + tr11 * cr3; |
| 2155 |
4
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx6] = ti12 * ci5 - ti11 * ci4; |
| 2156 | } | |
| 2157 |
1
1. radf5 : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 2158 | return; | |
| 2159 |
2
1. radf5 : changed conditional boundary → NO_COVERAGE 2. radf5 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; ++k) { |
| 2160 |
1
1. radf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2161 |
1
1. radf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 5 * idx1; |
| 2162 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 2163 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + ido; |
| 2164 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + ido; |
| 2165 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 2166 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx1 + idx0; |
| 2167 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + idx0; |
| 2168 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = idx8 + idx0; |
| 2169 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = idx9 + idx0; |
| 2170 |
2
1. radf5 : changed conditional boundary → NO_COVERAGE 2. radf5 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 2171 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 2172 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 2173 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i - 1 + iw3; |
| 2174 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx4 = i - 1 + iw4; |
| 2175 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 2176 | w1i = wtable_r[widx1]; | |
| 2177 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 2178 | w2i = wtable_r[widx2]; | |
| 2179 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
w3r = wtable_r[widx3 - 1]; |
| 2180 | w3i = wtable_r[widx3]; | |
| 2181 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
w4r = wtable_r[widx4 - 1]; |
| 2182 | w4i = wtable_r[widx4]; | |
| 2183 | ||
| 2184 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2185 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx15 = in_off + i; |
| 2186 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx16 = out_off + i; |
| 2187 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx17 = out_off + ic; |
| 2188 | ||
| 2189 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx15 + idx1; |
| 2190 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx15 + idx7; |
| 2191 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx15 + idx8; |
| 2192 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = idx15 + idx9; |
| 2193 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx5 = idx15 + idx10; |
| 2194 | ||
| 2195 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2196 | double i1r = in[iidx1]; | |
| 2197 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 2198 | double i2r = in[iidx2]; | |
| 2199 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 2200 | double i3r = in[iidx3]; | |
| 2201 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 2202 | double i4r = in[iidx4]; | |
| 2203 |
1
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i5i = in[iidx5 - 1]; |
| 2204 | double i5r = in[iidx5]; | |
| 2205 | ||
| 2206 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr2 = w1r * i2i + w1i * i2r; |
| 2207 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
di2 = w1r * i2r - w1i * i2i; |
| 2208 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr3 = w2r * i3i + w2i * i3r; |
| 2209 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
di3 = w2r * i3r - w2i * i3i; |
| 2210 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr4 = w3r * i4i + w3i * i4r; |
| 2211 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
di4 = w3r * i4r - w3i * i4i; |
| 2212 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr5 = w4r * i5i + w4i * i5r; |
| 2213 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
di5 = w4r * i5r - w4i * i5i; |
| 2214 | ||
| 2215 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = dr2 + dr5; |
| 2216 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
ci5 = dr5 - dr2; |
| 2217 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
cr5 = di2 - di5; |
| 2218 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = di2 + di5; |
| 2219 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = dr3 + dr4; |
| 2220 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = dr4 - dr3; |
| 2221 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
cr4 = di3 - di4; |
| 2222 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci3 = di3 + di4; |
| 2223 | ||
| 2224 |
4
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + tr11 * cr2 + tr12 * cr3; |
| 2225 |
4
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + tr11 * ci2 + tr12 * ci3; |
| 2226 |
4
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i1i + tr12 * cr2 + tr11 * cr3; |
| 2227 |
4
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double multiplication with division → NO_COVERAGE 4. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti3 = i1r + tr12 * ci2 + tr11 * ci3; |
| 2228 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr5 = ti11 * cr5 + ti12 * cr4; |
| 2229 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti5 = ti11 * ci5 + ti12 * ci4; |
| 2230 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = ti12 * cr5 - ti11 * cr4; |
| 2231 |
3
1. radf5 : Replaced double multiplication with division → NO_COVERAGE 2. radf5 : Replaced double multiplication with division → NO_COVERAGE 3. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = ti12 * ci5 - ti11 * ci4; |
| 2232 | ||
| 2233 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx16 + idx2; |
| 2234 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx17 + idx3; |
| 2235 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx16 + idx4; |
| 2236 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = idx17 + idx5; |
| 2237 |
1
1. radf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx5 = idx16 + idx6; |
| 2238 | ||
| 2239 |
3
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE 3. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = i1i + cr2 + cr3; |
| 2240 |
2
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + ci2 + ci3; |
| 2241 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 - 1] = tr2 + tr5; |
| 2242 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = tr2 - tr5; |
| 2243 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = ti2 + ti5; |
| 2244 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = ti5 - ti2; |
| 2245 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx5 - 1] = tr3 + tr4; |
| 2246 |
2
1. radf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 - 1] = tr3 - tr4; |
| 2247 |
1
1. radf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx5] = ti3 + ti4; |
| 2248 |
1
1. radf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4] = ti4 - ti3; |
| 2249 | } | |
| 2250 | } | |
| 2251 | } | |
| 2252 | ||
| 2253 | /*------------------------------------------------- | |
| 2254 | radb5: Real FFT's backward processing of factor 5 | |
| 2255 | -------------------------------------------------*/ | |
| 2256 | void radb5(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 2257 | final double tr11 = 0.309016994374947451262869435595348477; | |
| 2258 | final double ti11 = 0.951056516295153531181938433292089030; | |
| 2259 | final double tr12 = -0.809016994374947340240566973079694435; | |
| 2260 | final double ti12 = 0.587785252292473248125759255344746634; | |
| 2261 | int i, ic; | |
| 2262 | double ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5, w1r, w1i, w2r, w2i, w3r, w3i, w4r, w4i; | |
| 2263 | int iw1, iw2, iw3, iw4; | |
| 2264 | iw1 = offset; | |
| 2265 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 2266 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 2267 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw4 = iw3 + ido; |
| 2268 | ||
| 2269 |
1
1. radb5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 2270 |
2
1. radb5 : changed conditional boundary → NO_COVERAGE 2. radb5 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2271 |
1
1. radb5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2272 |
1
1. radb5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 5 * idx1; |
| 2273 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 2274 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + ido; |
| 2275 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + ido; |
| 2276 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 2277 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx1 + idx0; |
| 2278 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + idx0; |
| 2279 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = idx8 + idx0; |
| 2280 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = idx9 + idx0; |
| 2281 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
int idx11 = in_off + ido - 1; |
| 2282 | ||
| 2283 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[in_off + idx2]; |
| 2284 | ||
| 2285 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE |
ti5 = 2 * in[in_off + idx4]; |
| 2286 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE |
ti4 = 2 * in[in_off + idx6]; |
| 2287 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE |
tr2 = 2 * in[idx11 + idx3]; |
| 2288 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE |
tr3 = 2 * in[idx11 + idx5]; |
| 2289 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i1r + tr11 * tr2 + tr12 * tr3; |
| 2290 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = i1r + tr12 * tr2 + tr11 * tr3; |
| 2291 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ci5 = ti11 * ti5 + ti12 * ti4; |
| 2292 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = ti12 * ti5 - ti11 * ti4; |
| 2293 | ||
| 2294 |
3
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx1] = i1r + tr2 + tr3; |
| 2295 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx7] = cr2 - ci5; |
| 2296 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[out_off + idx8] = cr3 - ci4; |
| 2297 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx9] = cr3 + ci4; |
| 2298 |
2
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx10] = cr2 + ci5; |
| 2299 | } | |
| 2300 |
1
1. radb5 : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 2301 | return; | |
| 2302 |
2
1. radb5 : changed conditional boundary → NO_COVERAGE 2. radb5 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; ++k) { |
| 2303 |
1
1. radb5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2304 |
1
1. radb5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = 5 * idx1; |
| 2305 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = idx2 + ido; |
| 2306 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + ido; |
| 2307 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + ido; |
| 2308 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx5 + ido; |
| 2309 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = idx1 + idx0; |
| 2310 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = idx7 + idx0; |
| 2311 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = idx8 + idx0; |
| 2312 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx10 = idx9 + idx0; |
| 2313 |
2
1. radb5 : changed conditional boundary → NO_COVERAGE 2. radb5 : negated conditional → NO_COVERAGE |
for (i = 2; i < ido; i += 2) { |
| 2314 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2315 |
2
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i - 1 + iw1; |
| 2316 |
2
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i - 1 + iw2; |
| 2317 |
2
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i - 1 + iw3; |
| 2318 |
2
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx4 = i - 1 + iw4; |
| 2319 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[widx1 - 1]; |
| 2320 | w1i = wtable_r[widx1]; | |
| 2321 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable_r[widx2 - 1]; |
| 2322 | w2i = wtable_r[widx2]; | |
| 2323 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
w3r = wtable_r[widx3 - 1]; |
| 2324 | w3i = wtable_r[widx3]; | |
| 2325 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
w4r = wtable_r[widx4 - 1]; |
| 2326 | w4i = wtable_r[widx4]; | |
| 2327 | ||
| 2328 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx15 = in_off + i; |
| 2329 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx16 = in_off + ic; |
| 2330 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx17 = out_off + i; |
| 2331 | ||
| 2332 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx15 + idx2; |
| 2333 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx16 + idx3; |
| 2334 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = idx15 + idx4; |
| 2335 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = idx16 + idx5; |
| 2336 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx5 = idx15 + idx6; |
| 2337 | ||
| 2338 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2339 | double i1r = in[iidx1]; | |
| 2340 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 2341 | double i2r = in[iidx2]; | |
| 2342 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 2343 | double i3r = in[iidx3]; | |
| 2344 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 2345 | double i4r = in[iidx4]; | |
| 2346 |
1
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i5i = in[iidx5 - 1]; |
| 2347 | double i5r = in[iidx5]; | |
| 2348 | ||
| 2349 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ti5 = i3r + i2r; |
| 2350 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
ti2 = i3r - i2r; |
| 2351 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ti4 = i5r + i4r; |
| 2352 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
ti3 = i5r - i4r; |
| 2353 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
tr5 = i3i - i2i; |
| 2354 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i3i + i2i; |
| 2355 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = i5i - i4i; |
| 2356 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i5i + i4i; |
| 2357 | ||
| 2358 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i1i + tr11 * tr2 + tr12 * tr3; |
| 2359 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = i1r + tr11 * ti2 + tr12 * ti3; |
| 2360 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = i1i + tr12 * tr2 + tr11 * tr3; |
| 2361 |
4
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ci3 = i1r + tr12 * ti2 + tr11 * ti3; |
| 2362 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
cr5 = ti11 * tr5 + ti12 * tr4; |
| 2363 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
ci5 = ti11 * ti5 + ti12 * ti4; |
| 2364 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
cr4 = ti12 * tr5 - ti11 * tr4; |
| 2365 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = ti12 * ti5 - ti11 * ti4; |
| 2366 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
dr3 = cr3 - ci4; |
| 2367 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
dr4 = cr3 + ci4; |
| 2368 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
di3 = ci3 + cr4; |
| 2369 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
di4 = ci3 - cr4; |
| 2370 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
dr5 = cr2 + ci5; |
| 2371 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
dr2 = cr2 - ci5; |
| 2372 |
1
1. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
di5 = ci2 - cr5; |
| 2373 |
1
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
di2 = ci2 + cr5; |
| 2374 | ||
| 2375 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx17 + idx1; |
| 2376 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx17 + idx7; |
| 2377 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = idx17 + idx8; |
| 2378 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = idx17 + idx9; |
| 2379 |
1
1. radb5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx5 = idx17 + idx10; |
| 2380 | ||
| 2381 |
3
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = i1i + tr2 + tr3; |
| 2382 |
2
1. radb5 : Replaced double addition with subtraction → NO_COVERAGE 2. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + ti2 + ti3; |
| 2383 |
4
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = w1r * dr2 - w1i * di2; |
| 2384 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = w1r * di2 + w1i * dr2; |
| 2385 |
4
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3 - 1] = w2r * dr3 - w2i * di3; |
| 2386 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3] = w2r * di3 + w2i * dr3; |
| 2387 |
4
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 - 1] = w3r * dr4 - w3i * di4; |
| 2388 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx4] = w3r * di4 + w3i * dr4; |
| 2389 |
4
1. radb5 : Replaced integer subtraction with addition → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double multiplication with division → NO_COVERAGE 4. radb5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx5 - 1] = w4r * dr5 - w4i * di5; |
| 2390 |
3
1. radb5 : Replaced double multiplication with division → NO_COVERAGE 2. radb5 : Replaced double multiplication with division → NO_COVERAGE 3. radb5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx5] = w4r * di5 + w4i * dr5; |
| 2391 | } | |
| 2392 | } | |
| 2393 | } | |
| 2394 | ||
| 2395 | /*--------------------------------------------------------- | |
| 2396 | radfg: Real FFT's forward processing of general factor | |
| 2397 | --------------------------------------------------------*/ | |
| 2398 | void radfg(final int ido, final int ip, final int l1, final int idl1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 2399 | int idij, ipph, j2, ic, jc, lc, is, nbd; | |
| 2400 | double dc2, ai1, ai2, ar1, ar2, ds2, dcp, arg, dsp, ar1h, ar2h, w1r, w1i; | |
| 2401 | int iw1 = offset; | |
| 2402 | ||
| 2403 |
1
1. radfg : Replaced double division with multiplication → NO_COVERAGE |
arg = TWO_PI / ip; |
| 2404 | dcp = Math.cos(arg); | |
| 2405 | dsp = Math.sin(arg); | |
| 2406 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer division with multiplication → NO_COVERAGE |
ipph = (ip + 1) / 2; |
| 2407 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced integer division with multiplication → NO_COVERAGE |
nbd = (ido - 1) / 2; |
| 2408 |
1
1. radfg : negated conditional → NO_COVERAGE |
if (ido != 1) { |
| 2409 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) |
| 2410 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
out[out_off + ik] = in[in_off + ik]; |
| 2411 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2412 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2413 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2414 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = k * ido + idx1; |
| 2415 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
out[out_off + idx2] = in[in_off + idx2]; |
| 2416 | } | |
| 2417 | } | |
| 2418 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
if (nbd <= l1) { |
| 2419 |
1
1. radfg : removed negation → NO_COVERAGE |
is = -ido; |
| 2420 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2421 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
is += ido; |
| 2422 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
idij = is - 1; |
| 2423 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2424 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2425 |
1
1. radfg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 2426 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idij + iw1; |
| 2427 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + i; |
| 2428 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = out_off + i; |
| 2429 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[idx2 - 1]; |
| 2430 | w1i = wtable_r[idx2]; | |
| 2431 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2432 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2433 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx5 + idx3; |
| 2434 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx4 + idx3; |
| 2435 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2436 | double i1r = in[iidx1]; | |
| 2437 | ||
| 2438 |
4
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = w1r * i1i + w1i * i1r; |
| 2439 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1] = w1r * i1r - w1i * i1i; |
| 2440 | } | |
| 2441 | } | |
| 2442 | } | |
| 2443 | } else { | |
| 2444 |
1
1. radfg : removed negation → NO_COVERAGE |
is = -ido; |
| 2445 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2446 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
is += ido; |
| 2447 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2448 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2449 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
idij = is - 1; |
| 2450 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2451 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2452 |
1
1. radfg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 2453 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idij + iw1; |
| 2454 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[idx2 - 1]; |
| 2455 | w1i = wtable_r[idx2]; | |
| 2456 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i + idx3; |
| 2457 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + i + idx3; |
| 2458 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2459 | double i1r = in[iidx1]; | |
| 2460 | ||
| 2461 |
4
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = w1r * i1i + w1i * i1r; |
| 2462 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1] = w1r * i1r - w1i * i1i; |
| 2463 | } | |
| 2464 | } | |
| 2465 | } | |
| 2466 | } | |
| 2467 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
if (nbd >= l1) { |
| 2468 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2469 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2470 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2471 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2472 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2473 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2474 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = k * ido + idx2; |
| 2475 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2476 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = in_off + i; |
| 2477 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = out_off + i; |
| 2478 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx5 + idx3; |
| 2479 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx5 + idx4; |
| 2480 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx6 + idx3; |
| 2481 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx6 + idx4; |
| 2482 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2483 | double o1r = out[oidx1]; | |
| 2484 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o2i = out[oidx2 - 1]; |
| 2485 | double o2r = out[oidx2]; | |
| 2486 | ||
| 2487 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1 - 1] = o1i + o2i; |
| 2488 |
1
1. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = o1r + o2r; |
| 2489 | ||
| 2490 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2 - 1] = o1r - o2r; |
| 2491 |
1
1. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2] = o2i - o1i; |
| 2492 | } | |
| 2493 | } | |
| 2494 | } | |
| 2495 | } else { | |
| 2496 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2497 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2498 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2499 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2500 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2501 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = in_off + i; |
| 2502 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = out_off + i; |
| 2503 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2504 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2505 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = k * ido + idx2; |
| 2506 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx5 + idx3; |
| 2507 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx5 + idx4; |
| 2508 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx6 + idx3; |
| 2509 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx6 + idx4; |
| 2510 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2511 | double o1r = out[oidx1]; | |
| 2512 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o2i = out[oidx2 - 1]; |
| 2513 | double o2r = out[oidx2]; | |
| 2514 | ||
| 2515 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1 - 1] = o1i + o2i; |
| 2516 |
1
1. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = o1r + o2r; |
| 2517 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2 - 1] = o1r - o2r; |
| 2518 |
1
1. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2] = o2i - o1i; |
| 2519 | } | |
| 2520 | } | |
| 2521 | } | |
| 2522 | } | |
| 2523 | } else { | |
| 2524 |
1
1. radfg : removed call to java/lang/System::arraycopy → NO_COVERAGE |
System.arraycopy(out, out_off, in, in_off, idl1); |
| 2525 | } | |
| 2526 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2527 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2528 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2529 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2530 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2531 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2532 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = k * ido + idx2; |
| 2533 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx3; |
| 2534 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = out_off + idx4; |
| 2535 | double o1r = out[oidx1]; | |
| 2536 | double o2r = out[oidx2]; | |
| 2537 | ||
| 2538 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[in_off + idx3] = o1r + o2r; |
| 2539 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[in_off + idx4] = o2r - o1r; |
| 2540 | } | |
| 2541 | } | |
| 2542 | ||
| 2543 | ar1 = 1; | |
| 2544 | ai1 = 0; | |
| 2545 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = (ip - 1) * idl1; |
| 2546 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int l = 1; l < ipph; l++) { |
| 2547 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
lc = ip - l; |
| 2548 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double subtraction with addition → NO_COVERAGE |
ar1h = dcp * ar1 - dsp * ai1; |
| 2549 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double addition with subtraction → NO_COVERAGE |
ai1 = dcp * ai1 + dsp * ar1; |
| 2550 | ar1 = ar1h; | |
| 2551 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = l * idl1; |
| 2552 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = lc * idl1; |
| 2553 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2554 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = out_off + ik; |
| 2555 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + ik; |
| 2556 |
4
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx3 + idx1] = in[idx4] + ar1 * in[idx4 + idl1]; |
| 2557 |
3
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE |
out[idx3 + idx2] = ai1 * in[idx4 + idx0]; |
| 2558 | } | |
| 2559 | dc2 = ar1; | |
| 2560 | ds2 = ai1; | |
| 2561 | ar2 = ar1; | |
| 2562 | ai2 = ai1; | |
| 2563 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 2; j < ipph; j++) { |
| 2564 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2565 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double subtraction with addition → NO_COVERAGE |
ar2h = dc2 * ar2 - ds2 * ai2; |
| 2566 |
3
1. radfg : Replaced double multiplication with division → NO_COVERAGE 2. radfg : Replaced double multiplication with division → NO_COVERAGE 3. radfg : Replaced double addition with subtraction → NO_COVERAGE |
ai2 = dc2 * ai2 + ds2 * ar2; |
| 2567 | ar2 = ar2h; | |
| 2568 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = j * idl1; |
| 2569 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = jc * idl1; |
| 2570 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2571 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = out_off + ik; |
| 2572 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = in_off + ik; |
| 2573 |
4
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx5 + idx1] += ar2 * in[idx6 + idx3]; |
| 2574 |
4
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced double multiplication with division → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx5 + idx2] += ai2 * in[idx6 + idx4]; |
| 2575 | } | |
| 2576 | } | |
| 2577 | } | |
| 2578 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2579 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * idl1; |
| 2580 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2581 |
4
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE 4. radfg : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + ik] += in[in_off + ik + idx1]; |
| 2582 | } | |
| 2583 | } | |
| 2584 | ||
| 2585 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
if (ido >= l1) { |
| 2586 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2587 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2588 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = idx1 * ip; |
| 2589 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 2590 |
4
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE 4. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
in[in_off + i + idx2] = out[out_off + i + idx1]; |
| 2591 | } | |
| 2592 | } | |
| 2593 | } else { | |
| 2594 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 2595 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2596 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2597 |
5
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE 4. radfg : Replaced integer addition with subtraction → NO_COVERAGE 5. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
in[in_off + i + idx1 * ip] = out[out_off + i + idx1]; |
| 2598 | } | |
| 2599 | } | |
| 2600 | } | |
| 2601 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx01 = ip * ido; |
| 2602 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2603 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2604 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
j2 = 2 * j; |
| 2605 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2606 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2607 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = j2 * ido; |
| 2608 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2609 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = k * ido; |
| 2610 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx4 + idx1; |
| 2611 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = idx4 + idx2; |
| 2612 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx7 = k * idx01; |
| 2613 |
6
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer subtraction with addition → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE 4. radfg : Replaced integer subtraction with addition → NO_COVERAGE 5. radfg : Replaced integer addition with subtraction → NO_COVERAGE 6. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
in[in_off + ido - 1 + idx3 - ido + idx7] = out[out_off + idx5]; |
| 2614 |
3
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
in[in_off + idx3 + idx7] = out[out_off + idx6]; |
| 2615 | } | |
| 2616 | } | |
| 2617 |
1
1. radfg : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 2618 | return; | |
| 2619 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
if (nbd >= l1) { |
| 2620 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2621 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2622 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
j2 = 2 * j; |
| 2623 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2624 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2625 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = j2 * ido; |
| 2626 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2627 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = k * idx01; |
| 2628 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = k * ido; |
| 2629 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2630 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2631 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = in_off + i; |
| 2632 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = in_off + ic; |
| 2633 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = out_off + i; |
| 2634 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx6 + idx3 + idx4; |
| 2635 |
3
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer subtraction with addition → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx7 + idx3 - ido + idx4; |
| 2636 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx8 + idx5 + idx1; |
| 2637 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx8 + idx5 + idx2; |
| 2638 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2639 | double o1r = out[oidx1]; | |
| 2640 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o2i = out[oidx2 - 1]; |
| 2641 | double o2r = out[oidx2]; | |
| 2642 | ||
| 2643 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1 - 1] = o1i + o2i; |
| 2644 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2 - 1] = o1i - o2i; |
| 2645 |
1
1. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = o1r + o2r; |
| 2646 |
1
1. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2] = o2r - o1r; |
| 2647 | } | |
| 2648 | } | |
| 2649 | } | |
| 2650 | } else { | |
| 2651 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2652 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2653 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
j2 = 2 * j; |
| 2654 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2655 |
2
1. radfg : Replaced integer multiplication with division → NO_COVERAGE 2. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2656 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = j2 * ido; |
| 2657 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2658 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2659 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = in_off + i; |
| 2660 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = in_off + ic; |
| 2661 |
1
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = out_off + i; |
| 2662 |
2
1. radfg : changed conditional boundary → NO_COVERAGE 2. radfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2663 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = k * idx01; |
| 2664 |
1
1. radfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = k * ido; |
| 2665 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx6 + idx3 + idx4; |
| 2666 |
3
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer subtraction with addition → NO_COVERAGE 3. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx7 + idx3 - ido + idx4; |
| 2667 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx8 + idx5 + idx1; |
| 2668 |
2
1. radfg : Replaced integer addition with subtraction → NO_COVERAGE 2. radfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx8 + idx5 + idx2; |
| 2669 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2670 | double o1r = out[oidx1]; | |
| 2671 |
1
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o2i = out[oidx2 - 1]; |
| 2672 | double o2r = out[oidx2]; | |
| 2673 | ||
| 2674 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1 - 1] = o1i + o2i; |
| 2675 |
2
1. radfg : Replaced integer subtraction with addition → NO_COVERAGE 2. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2 - 1] = o1i - o2i; |
| 2676 |
1
1. radfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = o1r + o2r; |
| 2677 |
1
1. radfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx2] = o2r - o1r; |
| 2678 | } | |
| 2679 | } | |
| 2680 | } | |
| 2681 | } | |
| 2682 | } | |
| 2683 | ||
| 2684 | /*--------------------------------------------------------- | |
| 2685 | radbg: Real FFT's backward processing of general factor | |
| 2686 | --------------------------------------------------------*/ | |
| 2687 | void radbg(final int ido, final int ip, final int l1, final int idl1, final double in[], final int in_off, final double out[], final int out_off, final int offset) { | |
| 2688 | int idij, ipph, j2, ic, jc, lc, is; | |
| 2689 | double dc2, ai1, ai2, ar1, ar2, ds2, w1r, w1i; | |
| 2690 | int nbd; | |
| 2691 | double dcp, arg, dsp, ar1h, ar2h; | |
| 2692 | int iw1 = offset; | |
| 2693 | ||
| 2694 |
1
1. radbg : Replaced double division with multiplication → NO_COVERAGE |
arg = TWO_PI / ip; |
| 2695 | dcp = Math.cos(arg); | |
| 2696 | dsp = Math.sin(arg); | |
| 2697 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced integer division with multiplication → NO_COVERAGE |
nbd = (ido - 1) / 2; |
| 2698 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer division with multiplication → NO_COVERAGE |
ipph = (ip + 1) / 2; |
| 2699 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = ip * ido; |
| 2700 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
if (ido >= l1) { |
| 2701 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2702 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 2703 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = k * idx0; |
| 2704 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 2705 |
4
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced integer addition with subtraction → NO_COVERAGE 4. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
out[out_off + i + idx1] = in[in_off + i + idx2]; |
| 2706 | } | |
| 2707 | } | |
| 2708 | } else { | |
| 2709 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 2710 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = out_off + i; |
| 2711 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = in_off + i; |
| 2712 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2713 |
4
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced integer multiplication with division → NO_COVERAGE 4. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
out[idx1 + k * ido] = in[idx2 + k * idx0]; |
| 2714 | } | |
| 2715 | } | |
| 2716 | } | |
| 2717 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx0 = in_off + ido - 1; |
| 2718 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2719 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2720 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
j2 = 2 * j; |
| 2721 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2722 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2723 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = j2 * ido; |
| 2724 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2725 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx4 = k * ido; |
| 2726 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = idx4 * ip; |
| 2727 |
3
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx1 = iidx0 + idx3 + idx5 - ido; |
| 2728 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = in_off + idx3 + idx5; |
| 2729 | double i1r = in[iidx1]; | |
| 2730 | double i2r = in[iidx2]; | |
| 2731 | ||
| 2732 |
3
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx4 + idx1] = i1r + i1r; |
| 2733 |
3
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[out_off + idx4 + idx2] = i2r + i2r; |
| 2734 | } | |
| 2735 | } | |
| 2736 | ||
| 2737 |
1
1. radbg : negated conditional → NO_COVERAGE |
if (ido != 1) { |
| 2738 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
if (nbd >= l1) { |
| 2739 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2740 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2741 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2742 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2743 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = 2 * j * ido; |
| 2744 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2745 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = k * ido + idx1; |
| 2746 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = k * ido + idx2; |
| 2747 |
3
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE 3. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = k * ip * ido + idx3; |
| 2748 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2749 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2750 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = out_off + i; |
| 2751 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = in_off + ic; |
| 2752 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + i; |
| 2753 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx7 + idx4; |
| 2754 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx7 + idx5; |
| 2755 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx9 + idx6; |
| 2756 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx2 = idx8 + idx6 - ido; |
| 2757 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double a1i = in[iidx1 - 1]; |
| 2758 | double a1r = in[iidx1]; | |
| 2759 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double a2i = in[iidx2 - 1]; |
| 2760 | double a2r = in[iidx2]; | |
| 2761 | ||
| 2762 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = a1i + a2i; |
| 2763 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = a1i - a2i; |
| 2764 |
1
1. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1] = a1r - a2r; |
| 2765 |
1
1. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = a1r + a2r; |
| 2766 | } | |
| 2767 | } | |
| 2768 | } | |
| 2769 | } else { | |
| 2770 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2771 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2772 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2773 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2774 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = 2 * j * ido; |
| 2775 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2776 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
ic = ido - i; |
| 2777 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = out_off + i; |
| 2778 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = in_off + ic; |
| 2779 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx9 = in_off + i; |
| 2780 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2781 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = k * ido + idx1; |
| 2782 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = k * ido + idx2; |
| 2783 |
3
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE 3. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx6 = k * ip * ido + idx3; |
| 2784 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx7 + idx4; |
| 2785 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx7 + idx5; |
| 2786 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx9 + idx6; |
| 2787 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx2 = idx8 + idx6 - ido; |
| 2788 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double a1i = in[iidx1 - 1]; |
| 2789 | double a1r = in[iidx1]; | |
| 2790 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double a2i = in[iidx2 - 1]; |
| 2791 | double a2r = in[iidx2]; | |
| 2792 | ||
| 2793 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 - 1] = a1i + a2i; |
| 2794 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 - 1] = a1i - a2i; |
| 2795 |
1
1. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1] = a1r - a2r; |
| 2796 |
1
1. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = a1r + a2r; |
| 2797 | } | |
| 2798 | } | |
| 2799 | } | |
| 2800 | } | |
| 2801 | } | |
| 2802 | ||
| 2803 | ar1 = 1; | |
| 2804 | ai1 = 0; | |
| 2805 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx01 = (ip - 1) * idl1; |
| 2806 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int l = 1; l < ipph; l++) { |
| 2807 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
lc = ip - l; |
| 2808 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double subtraction with addition → NO_COVERAGE |
ar1h = dcp * ar1 - dsp * ai1; |
| 2809 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
ai1 = dcp * ai1 + dsp * ar1; |
| 2810 | ar1 = ar1h; | |
| 2811 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = l * idl1; |
| 2812 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = lc * idl1; |
| 2813 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2814 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = in_off + ik; |
| 2815 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = out_off + ik; |
| 2816 |
4
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE 4. radbg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx3 + idx1] = out[idx4] + ar1 * out[idx4 + idl1]; |
| 2817 |
3
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE |
in[idx3 + idx2] = ai1 * out[idx4 + idx01]; |
| 2818 | } | |
| 2819 | dc2 = ar1; | |
| 2820 | ds2 = ai1; | |
| 2821 | ar2 = ar1; | |
| 2822 | ai2 = ai1; | |
| 2823 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 2; j < ipph; j++) { |
| 2824 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2825 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double subtraction with addition → NO_COVERAGE |
ar2h = dc2 * ar2 - ds2 * ai2; |
| 2826 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
ai2 = dc2 * ai2 + ds2 * ar2; |
| 2827 | ar2 = ar2h; | |
| 2828 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx5 = j * idl1; |
| 2829 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx6 = jc * idl1; |
| 2830 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2831 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx7 = in_off + ik; |
| 2832 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx8 = out_off + ik; |
| 2833 |
4
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE 4. radbg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx7 + idx1] += ar2 * out[idx8 + idx5]; |
| 2834 |
4
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE 4. radbg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx7 + idx2] += ai2 * out[idx8 + idx6]; |
| 2835 | } | |
| 2836 | } | |
| 2837 | } | |
| 2838 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2839 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * idl1; |
| 2840 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 2841 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = out_off + ik; |
| 2842 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx2] += out[idx2 + idx1]; |
| 2843 | } | |
| 2844 | } | |
| 2845 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2846 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2847 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2848 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2849 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2850 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = k * ido; |
| 2851 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx3; |
| 2852 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + idx3 + idx1; |
| 2853 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = in_off + idx3 + idx2; |
| 2854 | double i1r = in[iidx1]; | |
| 2855 | double i2r = in[iidx2]; | |
| 2856 | ||
| 2857 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 + idx1] = i1r - i2r; |
| 2858 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + idx2] = i1r + i2r; |
| 2859 | } | |
| 2860 | } | |
| 2861 | ||
| 2862 |
1
1. radbg : negated conditional → NO_COVERAGE |
if (ido == 1) |
| 2863 | return; | |
| 2864 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
if (nbd >= l1) { |
| 2865 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2866 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2867 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2868 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2869 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2870 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = k * ido; |
| 2871 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2872 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = out_off + i; |
| 2873 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = in_off + i; |
| 2874 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx4 + idx3 + idx1; |
| 2875 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx4 + idx3 + idx2; |
| 2876 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx5 + idx3 + idx1; |
| 2877 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx5 + idx3 + idx2; |
| 2878 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2879 | double i1r = in[iidx1]; | |
| 2880 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 2881 | double i2r = in[iidx2]; | |
| 2882 | ||
| 2883 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 - 1] = i1i - i2r; |
| 2884 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 - 1] = i1i + i2r; |
| 2885 |
1
1. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2i; |
| 2886 |
1
1. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = i1r - i2i; |
| 2887 | } | |
| 2888 | } | |
| 2889 | } | |
| 2890 | } else { | |
| 2891 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 2892 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 2893 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2894 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * l1 * ido; |
| 2895 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2896 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = out_off + i; |
| 2897 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = in_off + i; |
| 2898 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2899 |
1
1. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = k * ido; |
| 2900 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx4 + idx3 + idx1; |
| 2901 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx4 + idx3 + idx2; |
| 2902 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx5 + idx3 + idx1; |
| 2903 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx5 + idx3 + idx2; |
| 2904 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 2905 | double i1r = in[iidx1]; | |
| 2906 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 2907 | double i2r = in[iidx2]; | |
| 2908 | ||
| 2909 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 - 1] = i1i - i2r; |
| 2910 |
2
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 - 1] = i1i + i2r; |
| 2911 |
1
1. radbg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2i; |
| 2912 |
1
1. radbg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = i1r - i2i; |
| 2913 | } | |
| 2914 | } | |
| 2915 | } | |
| 2916 | } | |
| 2917 |
1
1. radbg : removed call to java/lang/System::arraycopy → NO_COVERAGE |
System.arraycopy(out, out_off, in, in_off, idl1); |
| 2918 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2919 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2920 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2921 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = k * ido + idx1; |
| 2922 |
2
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
in[in_off + idx2] = out[out_off + idx2]; |
| 2923 | } | |
| 2924 | } | |
| 2925 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
if (nbd <= l1) { |
| 2926 |
1
1. radbg : removed negation → NO_COVERAGE |
is = -ido; |
| 2927 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2928 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
is += ido; |
| 2929 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
idij = is - 1; |
| 2930 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2931 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2932 |
1
1. radbg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 2933 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idij + iw1; |
| 2934 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[idx2 - 1]; |
| 2935 | w1i = wtable_r[idx2]; | |
| 2936 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + i; |
| 2937 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = out_off + i; |
| 2938 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2939 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2940 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx4 + idx3; |
| 2941 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx5 + idx3; |
| 2942 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2943 | double o1r = out[oidx1]; | |
| 2944 | ||
| 2945 |
4
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE 4. radbg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx1 - 1] = w1r * o1i - w1i * o1r; |
| 2946 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = w1r * o1r + w1i * o1i; |
| 2947 | } | |
| 2948 | } | |
| 2949 | } | |
| 2950 | } else { | |
| 2951 |
1
1. radbg : removed negation → NO_COVERAGE |
is = -ido; |
| 2952 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 2953 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
is += ido; |
| 2954 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 2955 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 2956 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
idij = is - 1; |
| 2957 |
2
1. radbg : Replaced integer multiplication with division → NO_COVERAGE 2. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 2958 |
2
1. radbg : changed conditional boundary → NO_COVERAGE 2. radbg : negated conditional → NO_COVERAGE |
for (int i = 2; i < ido; i += 2) { |
| 2959 |
1
1. radbg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 2960 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idij + iw1; |
| 2961 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable_r[idx2 - 1]; |
| 2962 | w1i = wtable_r[idx2]; | |
| 2963 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + i; |
| 2964 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = out_off + i; |
| 2965 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx4 + idx3; |
| 2966 |
1
1. radbg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx5 + idx3; |
| 2967 |
1
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 2968 | double o1r = out[oidx1]; | |
| 2969 | ||
| 2970 |
4
1. radbg : Replaced integer subtraction with addition → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double multiplication with division → NO_COVERAGE 4. radbg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx1 - 1] = w1r * o1i - w1i * o1r; |
| 2971 |
3
1. radbg : Replaced double multiplication with division → NO_COVERAGE 2. radbg : Replaced double multiplication with division → NO_COVERAGE 3. radbg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = w1r * o1r + w1i * o1i; |
| 2972 | ||
| 2973 | } | |
| 2974 | } | |
| 2975 | } | |
| 2976 | } | |
| 2977 | } | |
| 2978 | ||
| 2979 | /*--------------------------------------------------------- | |
| 2980 | cfftf1: further processing of Complex forward FFT | |
| 2981 | --------------------------------------------------------*/ | |
| 2982 | void cfftf(double a[], int offa, int isign) { | |
| 2983 | int idot; | |
| 2984 | int l1, l2; | |
| 2985 | int na, nf, ip, iw, ido, idl1; | |
| 2986 | int[] nac = new int[1]; | |
| 2987 |
1
1. cfftf : Replaced integer multiplication with division → KILLED |
final int twon = 2 * n; |
| 2988 | ||
| 2989 | int iw1, iw2; | |
| 2990 | double[] ch = new double[twon]; | |
| 2991 | ||
| 2992 | iw1 = twon; | |
| 2993 |
1
1. cfftf : Replaced integer multiplication with division → KILLED |
iw2 = 4 * n; |
| 2994 | nac[0] = 0; | |
| 2995 |
1
1. cfftf : Replaced integer addition with subtraction → KILLED |
nf = (int) wtable[1 + iw2]; |
| 2996 | na = 0; | |
| 2997 | l1 = 1; | |
| 2998 | iw = iw1; | |
| 2999 |
3
1. cfftf : changed conditional boundary → KILLED 2. cfftf : Replaced integer addition with subtraction → KILLED 3. cfftf : negated conditional → KILLED |
for (int k1 = 2; k1 <= nf + 1; k1++) { |
| 3000 |
1
1. cfftf : Replaced integer addition with subtraction → KILLED |
ip = (int) wtable[k1 + iw2]; |
| 3001 |
1
1. cfftf : Replaced integer multiplication with division → SURVIVED |
l2 = ip * l1; |
| 3002 |
1
1. cfftf : Replaced integer division with multiplication → KILLED |
ido = n / l2; |
| 3003 |
1
1. cfftf : Replaced integer addition with subtraction → KILLED |
idot = ido + ido; |
| 3004 |
1
1. cfftf : Replaced integer multiplication with division → SURVIVED |
idl1 = idot * l1; |
| 3005 | switch (ip) { | |
| 3006 | case 4: | |
| 3007 |
1
1. cfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 3008 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf4 → NO_COVERAGE |
passf4(idot, l1, a, offa, ch, 0, iw, isign); |
| 3009 | } else { | |
| 3010 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf4 → NO_COVERAGE |
passf4(idot, l1, ch, 0, a, offa, iw, isign); |
| 3011 | } | |
| 3012 |
1
1. cfftf : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 3013 | break; | |
| 3014 | case 2: | |
| 3015 |
1
1. cfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 3016 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf2 → NO_COVERAGE |
passf2(idot, l1, a, offa, ch, 0, iw, isign); |
| 3017 | } else { | |
| 3018 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf2 → NO_COVERAGE |
passf2(idot, l1, ch, 0, a, offa, iw, isign); |
| 3019 | } | |
| 3020 |
1
1. cfftf : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 3021 | break; | |
| 3022 | case 3: | |
| 3023 |
1
1. cfftf : negated conditional → KILLED |
if (na == 0) { |
| 3024 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf3 → KILLED |
passf3(idot, l1, a, offa, ch, 0, iw, isign); |
| 3025 | } else { | |
| 3026 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf3 → NO_COVERAGE |
passf3(idot, l1, ch, 0, a, offa, iw, isign); |
| 3027 | } | |
| 3028 |
1
1. cfftf : Replaced integer subtraction with addition → SURVIVED |
na = 1 - na; |
| 3029 | break; | |
| 3030 | case 5: | |
| 3031 |
1
1. cfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 3032 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf5 → NO_COVERAGE |
passf5(idot, l1, a, offa, ch, 0, iw, isign); |
| 3033 | } else { | |
| 3034 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passf5 → NO_COVERAGE |
passf5(idot, l1, ch, 0, a, offa, iw, isign); |
| 3035 | } | |
| 3036 |
1
1. cfftf : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 3037 | break; | |
| 3038 | default: | |
| 3039 |
1
1. cfftf : negated conditional → NO_COVERAGE |
if (na == 0) { |
| 3040 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passfg → NO_COVERAGE |
passfg(nac, idot, ip, l1, idl1, a, offa, ch, 0, iw, isign); |
| 3041 | } else { | |
| 3042 |
1
1. cfftf : removed call to mikera/matrixx/algo/FFT::passfg → NO_COVERAGE |
passfg(nac, idot, ip, l1, idl1, ch, 0, a, offa, iw, isign); |
| 3043 | } | |
| 3044 |
1
1. cfftf : negated conditional → NO_COVERAGE |
if (nac[0] != 0) |
| 3045 |
1
1. cfftf : Replaced integer subtraction with addition → NO_COVERAGE |
na = 1 - na; |
| 3046 | break; | |
| 3047 | } | |
| 3048 | l1 = l2; | |
| 3049 |
3
1. cfftf : Replaced integer subtraction with addition → SURVIVED 2. cfftf : Replaced integer multiplication with division → SURVIVED 3. cfftf : Replaced integer addition with subtraction → SURVIVED |
iw += (ip - 1) * idot; |
| 3050 | } | |
| 3051 |
1
1. cfftf : negated conditional → KILLED |
if (na == 0) |
| 3052 | return; | |
| 3053 |
1
1. cfftf : removed call to java/lang/System::arraycopy → KILLED |
System.arraycopy(ch, 0, a, offa, twon); |
| 3054 | ||
| 3055 | } | |
| 3056 | ||
| 3057 | /*---------------------------------------------------------------------- | |
| 3058 | passf2: Complex FFT's forward/backward processing of factor 2; | |
| 3059 | isign is +1 for backward and -1 for forward transforms | |
| 3060 | ----------------------------------------------------------------------*/ | |
| 3061 | ||
| 3062 | void passf2(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset, final int isign) { | |
| 3063 | double t1i, t1r; | |
| 3064 | int iw1; | |
| 3065 | iw1 = offset; | |
| 3066 |
1
1. passf2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx = ido * l1; |
| 3067 |
2
1. passf2 : changed conditional boundary → NO_COVERAGE 2. passf2 : negated conditional → NO_COVERAGE |
if (ido <= 2) { |
| 3068 |
2
1. passf2 : changed conditional boundary → NO_COVERAGE 2. passf2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3069 |
1
1. passf2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = k * ido; |
| 3070 |
2
1. passf2 : Replaced integer multiplication with division → NO_COVERAGE 2. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + 2 * idx0; |
| 3071 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3072 | double a1r = in[iidx1]; | |
| 3073 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
double a1i = in[iidx1 + 1]; |
| 3074 | double a2r = in[iidx2]; | |
| 3075 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
double a2i = in[iidx2 + 1]; |
| 3076 | ||
| 3077 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx0; |
| 3078 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx; |
| 3079 |
1
1. passf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = a1r + a2r; |
| 3080 |
2
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = a1i + a2i; |
| 3081 |
1
1. passf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = a1r - a2r; |
| 3082 |
2
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2 + 1] = a1i - a2i; |
| 3083 | } | |
| 3084 | } else { | |
| 3085 |
2
1. passf2 : changed conditional boundary → NO_COVERAGE 2. passf2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3086 |
3
1. passf2 : changed conditional boundary → NO_COVERAGE 2. passf2 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf2 : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido - 1; i += 2) { |
| 3087 |
1
1. passf2 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = k * ido; |
| 3088 |
3
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced integer multiplication with division → NO_COVERAGE 3. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + i + 2 * idx0; |
| 3089 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3090 | double i1r = in[iidx1]; | |
| 3091 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
double i1i = in[iidx1 + 1]; |
| 3092 | double i2r = in[iidx2]; | |
| 3093 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
double i2i = in[iidx2 + 1]; |
| 3094 | ||
| 3095 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i + iw1; |
| 3096 | double w1r = wtable[widx1]; | |
| 3097 |
2
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced double multiplication with division → NO_COVERAGE |
double w1i = isign * wtable[widx1 + 1]; |
| 3098 | ||
| 3099 |
1
1. passf2 : Replaced double subtraction with addition → NO_COVERAGE |
t1r = i1r - i2r; |
| 3100 |
1
1. passf2 : Replaced double subtraction with addition → NO_COVERAGE |
t1i = i1i - i2i; |
| 3101 | ||
| 3102 |
2
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i + idx0; |
| 3103 |
1
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx; |
| 3104 |
1
1. passf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2r; |
| 3105 |
2
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = i1i + i2i; |
| 3106 |
3
1. passf2 : Replaced double multiplication with division → NO_COVERAGE 2. passf2 : Replaced double multiplication with division → NO_COVERAGE 3. passf2 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = w1r * t1r - w1i * t1i; |
| 3107 |
4
1. passf2 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf2 : Replaced double multiplication with division → NO_COVERAGE 3. passf2 : Replaced double multiplication with division → NO_COVERAGE 4. passf2 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = w1r * t1i + w1i * t1r; |
| 3108 | } | |
| 3109 | } | |
| 3110 | } | |
| 3111 | } | |
| 3112 | ||
| 3113 | /*---------------------------------------------------------------------- | |
| 3114 | passf3: Complex FFT's forward/backward processing of factor 3; | |
| 3115 | isign is +1 for backward and -1 for forward transforms | |
| 3116 | ----------------------------------------------------------------------*/ | |
| 3117 | void passf3(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset, final int isign) { | |
| 3118 | final double taur = -0.5; | |
| 3119 | final double taui = 0.866025403784438707610604524234076962; | |
| 3120 | double ci2, ci3, di2, di3, cr2, cr3, dr2, dr3, ti2, tr2; | |
| 3121 | int iw1, iw2; | |
| 3122 | ||
| 3123 | iw1 = offset; | |
| 3124 |
1
1. passf3 : Replaced integer addition with subtraction → SURVIVED |
iw2 = iw1 + ido; |
| 3125 | ||
| 3126 |
1
1. passf3 : Replaced integer multiplication with division → KILLED |
final int idxt = l1 * ido; |
| 3127 | ||
| 3128 |
1
1. passf3 : negated conditional → SURVIVED |
if (ido == 2) { |
| 3129 |
2
1. passf3 : changed conditional boundary → KILLED 2. passf3 : negated conditional → KILLED |
for (int k = 1; k <= l1; k++) { |
| 3130 |
4
1. passf3 : Replaced integer multiplication with division → SURVIVED 2. passf3 : Replaced integer subtraction with addition → KILLED 3. passf3 : Replaced integer multiplication with division → KILLED 4. passf3 : Replaced integer addition with subtraction → KILLED |
int iidx1 = in_off + (3 * k - 2) * ido; |
| 3131 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
int iidx2 = iidx1 + ido; |
| 3132 |
1
1. passf3 : Replaced integer subtraction with addition → KILLED |
int iidx3 = iidx1 - ido; |
| 3133 | double i1r = in[iidx1]; | |
| 3134 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
double i1i = in[iidx1 + 1]; |
| 3135 | double i2r = in[iidx2]; | |
| 3136 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
double i2i = in[iidx2 + 1]; |
| 3137 | double i3r = in[iidx3]; | |
| 3138 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
double i3i = in[iidx3 + 1]; |
| 3139 | ||
| 3140 |
1
1. passf3 : Replaced double addition with subtraction → KILLED |
tr2 = i1r + i2r; |
| 3141 |
2
1. passf3 : Replaced double multiplication with division → KILLED 2. passf3 : Replaced double addition with subtraction → KILLED |
cr2 = i3r + taur * tr2; |
| 3142 |
1
1. passf3 : Replaced double addition with subtraction → SURVIVED |
ti2 = i1i + i2i; |
| 3143 |
2
1. passf3 : Replaced double multiplication with division → SURVIVED 2. passf3 : Replaced double addition with subtraction → SURVIVED |
ci2 = i3i + taur * ti2; |
| 3144 |
3
1. passf3 : Replaced double multiplication with division → SURVIVED 2. passf3 : Replaced double subtraction with addition → SURVIVED 3. passf3 : Replaced double multiplication with division → SURVIVED |
cr3 = isign * taui * (i1r - i2r); |
| 3145 |
3
1. passf3 : Replaced double multiplication with division → KILLED 2. passf3 : Replaced double subtraction with addition → KILLED 3. passf3 : Replaced double multiplication with division → KILLED |
ci3 = isign * taui * (i1i - i2i); |
| 3146 | ||
| 3147 |
3
1. passf3 : Replaced integer multiplication with division → SURVIVED 2. passf3 : Replaced integer addition with subtraction → SURVIVED 3. passf3 : Replaced integer subtraction with addition → KILLED |
int oidx1 = out_off + (k - 1) * ido; |
| 3148 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
int oidx2 = oidx1 + idxt; |
| 3149 |
1
1. passf3 : Replaced integer addition with subtraction → KILLED |
int oidx3 = oidx2 + idxt; |
| 3150 |
1
1. passf3 : Replaced double addition with subtraction → KILLED |
out[oidx1] = in[iidx3] + tr2; |
| 3151 |
2
1. passf3 : Replaced double addition with subtraction → SURVIVED 2. passf3 : Replaced integer addition with subtraction → KILLED |
out[oidx1 + 1] = i3i + ti2; |
| 3152 |
1
1. passf3 : Replaced double subtraction with addition → KILLED |
out[oidx2] = cr2 - ci3; |
| 3153 |
2
1. passf3 : Replaced integer addition with subtraction → SURVIVED 2. passf3 : Replaced double addition with subtraction → SURVIVED |
out[oidx2 + 1] = ci2 + cr3; |
| 3154 |
1
1. passf3 : Replaced double addition with subtraction → KILLED |
out[oidx3] = cr2 + ci3; |
| 3155 |
2
1. passf3 : Replaced integer addition with subtraction → SURVIVED 2. passf3 : Replaced double subtraction with addition → SURVIVED |
out[oidx3 + 1] = ci2 - cr3; |
| 3156 | } | |
| 3157 | } else { | |
| 3158 |
2
1. passf3 : changed conditional boundary → NO_COVERAGE 2. passf3 : negated conditional → NO_COVERAGE |
for (int k = 1; k <= l1; k++) { |
| 3159 |
4
1. passf3 : Replaced integer multiplication with division → NO_COVERAGE 2. passf3 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf3 : Replaced integer multiplication with division → NO_COVERAGE 4. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = in_off + (3 * k - 2) * ido; |
| 3160 |
3
1. passf3 : Replaced integer subtraction with addition → NO_COVERAGE 2. passf3 : Replaced integer multiplication with division → NO_COVERAGE 3. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = out_off + (k - 1) * ido; |
| 3161 |
3
1. passf3 : changed conditional boundary → NO_COVERAGE 2. passf3 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf3 : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido - 1; i += 2) { |
| 3162 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = i + idx1; |
| 3163 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3164 |
1
1. passf3 : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx3 = iidx1 - ido; |
| 3165 | double a1r = in[iidx1]; | |
| 3166 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
double a1i = in[iidx1 + 1]; |
| 3167 | double a2r = in[iidx2]; | |
| 3168 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
double a2i = in[iidx2 + 1]; |
| 3169 | double a3r = in[iidx3]; | |
| 3170 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
double a3i = in[iidx3 + 1]; |
| 3171 | ||
| 3172 |
1
1. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = a1r + a2r; |
| 3173 |
2
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = a3r + taur * tr2; |
| 3174 |
1
1. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = a1i + a2i; |
| 3175 |
2
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = a3i + taur * ti2; |
| 3176 |
3
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double subtraction with addition → NO_COVERAGE 3. passf3 : Replaced double multiplication with division → NO_COVERAGE |
cr3 = isign * taui * (a1r - a2r); |
| 3177 |
3
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double subtraction with addition → NO_COVERAGE 3. passf3 : Replaced double multiplication with division → NO_COVERAGE |
ci3 = isign * taui * (a1i - a2i); |
| 3178 |
1
1. passf3 : Replaced double subtraction with addition → NO_COVERAGE |
dr2 = cr2 - ci3; |
| 3179 |
1
1. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
dr3 = cr2 + ci3; |
| 3180 |
1
1. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
di2 = ci2 + cr3; |
| 3181 |
1
1. passf3 : Replaced double subtraction with addition → NO_COVERAGE |
di3 = ci2 - cr3; |
| 3182 | ||
| 3183 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i + iw1; |
| 3184 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i + iw2; |
| 3185 | double w1r = wtable[widx1]; | |
| 3186 |
2
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE |
double w1i = isign * wtable[widx1 + 1]; |
| 3187 | double w2r = wtable[widx2]; | |
| 3188 |
2
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE |
double w2i = isign * wtable[widx2 + 1]; |
| 3189 | ||
| 3190 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = i + idx2; |
| 3191 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idxt; |
| 3192 |
1
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = oidx2 + idxt; |
| 3193 |
1
1. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = a3r + tr2; |
| 3194 |
2
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = a3i + ti2; |
| 3195 |
3
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE 3. passf3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = w1r * dr2 - w1i * di2; |
| 3196 |
4
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE 3. passf3 : Replaced double multiplication with division → NO_COVERAGE 4. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = w1r * di2 + w1i * dr2; |
| 3197 |
3
1. passf3 : Replaced double multiplication with division → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE 3. passf3 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3] = w2r * dr3 - w2i * di3; |
| 3198 |
4
1. passf3 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf3 : Replaced double multiplication with division → NO_COVERAGE 3. passf3 : Replaced double multiplication with division → NO_COVERAGE 4. passf3 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 + 1] = w2r * di3 + w2i * dr3; |
| 3199 | } | |
| 3200 | } | |
| 3201 | } | |
| 3202 | } | |
| 3203 | ||
| 3204 | /*---------------------------------------------------------------------- | |
| 3205 | passf4: Complex FFT's forward/backward processing of factor 4; | |
| 3206 | isign is +1 for backward and -1 for forward transforms | |
| 3207 | ----------------------------------------------------------------------*/ | |
| 3208 | void passf4(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset, final int isign) { | |
| 3209 | double ci2, ci3, ci4, cr2, cr3, cr4, ti1, ti2, ti3, ti4, tr1, tr2, tr3, tr4; | |
| 3210 | int iw1, iw2, iw3; | |
| 3211 | iw1 = offset; | |
| 3212 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 3213 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 3214 | ||
| 3215 |
1
1. passf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 3216 |
1
1. passf4 : negated conditional → NO_COVERAGE |
if (ido == 2) { |
| 3217 |
2
1. passf4 : changed conditional boundary → NO_COVERAGE 2. passf4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3218 |
1
1. passf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idxt1 = k * ido; |
| 3219 |
3
1. passf4 : Replaced integer multiplication with division → NO_COVERAGE 2. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 3. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + 4 * idxt1 + 1; |
| 3220 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3221 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = iidx2 + ido; |
| 3222 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = iidx3 + ido; |
| 3223 | ||
| 3224 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 3225 | double i1r = in[iidx1]; | |
| 3226 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 3227 | double i2r = in[iidx2]; | |
| 3228 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 3229 | double i3r = in[iidx3]; | |
| 3230 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 3231 | double i4r = in[iidx4]; | |
| 3232 | ||
| 3233 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti1 = i1r - i3r; |
| 3234 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + i3r; |
| 3235 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = i4r - i2r; |
| 3236 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti3 = i2r + i4r; |
| 3237 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr1 = i1i - i3i; |
| 3238 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + i3i; |
| 3239 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = i2i - i4i; |
| 3240 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i2i + i4i; |
| 3241 | ||
| 3242 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idxt1; |
| 3243 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx0; |
| 3244 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = oidx2 + idx0; |
| 3245 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = oidx3 + idx0; |
| 3246 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = tr2 + tr3; |
| 3247 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = ti2 + ti3; |
| 3248 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2] = tr1 + isign * tr4; |
| 3249 |
3
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = ti1 + isign * ti4; |
| 3250 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3] = tr2 - tr3; |
| 3251 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3 + 1] = ti2 - ti3; |
| 3252 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4] = tr1 - isign * tr4; |
| 3253 |
3
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 + 1] = ti1 - isign * ti4; |
| 3254 | } | |
| 3255 | } else { | |
| 3256 |
2
1. passf4 : changed conditional boundary → NO_COVERAGE 2. passf4 : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3257 |
1
1. passf4 : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 3258 |
3
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced integer multiplication with division → NO_COVERAGE 3. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = in_off + 1 + 4 * idx1; |
| 3259 |
3
1. passf4 : changed conditional boundary → NO_COVERAGE 2. passf4 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf4 : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido - 1; i += 2) { |
| 3260 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = i + idx2; |
| 3261 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3262 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx3 = iidx2 + ido; |
| 3263 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = iidx3 + ido; |
| 3264 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 3265 | double i1r = in[iidx1]; | |
| 3266 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 3267 | double i2r = in[iidx2]; | |
| 3268 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 3269 | double i3r = in[iidx3]; | |
| 3270 |
1
1. passf4 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 3271 | double i4r = in[iidx4]; | |
| 3272 | ||
| 3273 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti1 = i1r - i3r; |
| 3274 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + i3r; |
| 3275 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
ti3 = i2r + i4r; |
| 3276 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = i4r - i2r; |
| 3277 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
tr1 = i1i - i3i; |
| 3278 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + i3i; |
| 3279 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = i2i - i4i; |
| 3280 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i2i + i4i; |
| 3281 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
cr3 = tr2 - tr3; |
| 3282 |
1
1. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ci3 = ti2 - ti3; |
| 3283 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = tr1 + isign * tr4; |
| 3284 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
cr4 = tr1 - isign * tr4; |
| 3285 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = ti1 + isign * ti4; |
| 3286 |
2
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
ci4 = ti1 - isign * ti4; |
| 3287 | ||
| 3288 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i + iw1; |
| 3289 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i + iw2; |
| 3290 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i + iw3; |
| 3291 | double w1r = wtable[widx1]; | |
| 3292 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE |
double w1i = isign * wtable[widx1 + 1]; |
| 3293 | double w2r = wtable[widx2]; | |
| 3294 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE |
double w2i = isign * wtable[widx2 + 1]; |
| 3295 | double w3r = wtable[widx3]; | |
| 3296 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE |
double w3i = isign * wtable[widx3 + 1]; |
| 3297 | ||
| 3298 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i + idx1; |
| 3299 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx0; |
| 3300 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = oidx2 + idx0; |
| 3301 |
1
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = oidx3 + idx0; |
| 3302 |
1
1. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = tr2 + tr3; |
| 3303 |
2
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = ti2 + ti3; |
| 3304 |
3
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = w1r * cr2 - w1i * ci2; |
| 3305 |
4
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double multiplication with division → NO_COVERAGE 4. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = w1r * ci2 + w1i * cr2; |
| 3306 |
3
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3] = w2r * cr3 - w2i * ci3; |
| 3307 |
4
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double multiplication with division → NO_COVERAGE 4. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 + 1] = w2r * ci3 + w2i * cr3; |
| 3308 |
3
1. passf4 : Replaced double multiplication with division → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4] = w3r * cr4 - w3i * ci4; |
| 3309 |
4
1. passf4 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf4 : Replaced double multiplication with division → NO_COVERAGE 3. passf4 : Replaced double multiplication with division → NO_COVERAGE 4. passf4 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx4 + 1] = w3r * ci4 + w3i * cr4; |
| 3310 | } | |
| 3311 | } | |
| 3312 | } | |
| 3313 | } | |
| 3314 | ||
| 3315 | /*---------------------------------------------------------------------- | |
| 3316 | passf5: Complex FFT's forward/backward processing of factor 5; | |
| 3317 | isign is +1 for backward and -1 for forward transforms | |
| 3318 | ----------------------------------------------------------------------*/ | |
| 3319 | void passf5(final int ido, final int l1, final double in[], final int in_off, final double out[], final int out_off, final int offset, final int isign) | |
| 3320 | /* isign==-1 for forward transform and+1 for backward transform */ | |
| 3321 | { | |
| 3322 | final double tr11 = 0.309016994374947451262869435595348477; | |
| 3323 | final double ti11 = 0.951056516295153531181938433292089030; | |
| 3324 | final double tr12 = -0.809016994374947340240566973079694435; | |
| 3325 | final double ti12 = 0.587785252292473248125759255344746634; | |
| 3326 | double ci2, ci3, ci4, ci5, di3, di4, di5, di2, cr2, cr3, cr5, cr4, ti2, ti3, ti4, ti5, dr3, dr4, dr5, dr2, tr2, tr3, tr4, tr5; | |
| 3327 | int iw1, iw2, iw3, iw4; | |
| 3328 | ||
| 3329 | iw1 = offset; | |
| 3330 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw2 = iw1 + ido; |
| 3331 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw3 = iw2 + ido; |
| 3332 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
iw4 = iw3 + ido; |
| 3333 | ||
| 3334 |
1
1. passf5 : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 3335 | ||
| 3336 |
1
1. passf5 : negated conditional → NO_COVERAGE |
if (ido == 2) { |
| 3337 |
2
1. passf5 : changed conditional boundary → NO_COVERAGE 2. passf5 : negated conditional → NO_COVERAGE |
for (int k = 1; k <= l1; ++k) { |
| 3338 |
5
1. passf5 : Replaced integer multiplication with division → NO_COVERAGE 2. passf5 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf5 : Replaced integer multiplication with division → NO_COVERAGE 4. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 5. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + (5 * k - 4) * ido + 1; |
| 3339 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3340 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx3 = iidx1 - ido; |
| 3341 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = iidx2 + ido; |
| 3342 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx5 = iidx4 + ido; |
| 3343 | ||
| 3344 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 3345 | double i1r = in[iidx1]; | |
| 3346 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 3347 | double i2r = in[iidx2]; | |
| 3348 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 3349 | double i3r = in[iidx3]; | |
| 3350 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 3351 | double i4r = in[iidx4]; | |
| 3352 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i5i = in[iidx5 - 1]; |
| 3353 | double i5r = in[iidx5]; | |
| 3354 | ||
| 3355 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
ti5 = i1r - i5r; |
| 3356 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + i5r; |
| 3357 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = i2r - i4r; |
| 3358 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti3 = i2r + i4r; |
| 3359 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
tr5 = i1i - i5i; |
| 3360 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + i5i; |
| 3361 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = i2i - i4i; |
| 3362 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i2i + i4i; |
| 3363 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i3i + tr11 * tr2 + tr12 * tr3; |
| 3364 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = i3r + tr11 * ti2 + tr12 * ti3; |
| 3365 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = i3i + tr12 * tr2 + tr11 * tr3; |
| 3366 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci3 = i3r + tr12 * ti2 + tr11 * ti3; |
| 3367 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
cr5 = isign * (ti11 * tr5 + ti12 * tr4); |
| 3368 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
ci5 = isign * (ti11 * ti5 + ti12 * ti4); |
| 3369 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
cr4 = isign * (ti12 * tr5 - ti11 * tr4); |
| 3370 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
ci4 = isign * (ti12 * ti5 - ti11 * ti4); |
| 3371 | ||
| 3372 |
3
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. passf5 : Replaced integer multiplication with division → NO_COVERAGE 3. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + (k - 1) * ido; |
| 3373 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx0; |
| 3374 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = oidx2 + idx0; |
| 3375 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = oidx3 + idx0; |
| 3376 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx5 = oidx4 + idx0; |
| 3377 |
2
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i3i + tr2 + tr3; |
| 3378 |
3
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = i3r + ti2 + ti3; |
| 3379 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = cr2 - ci5; |
| 3380 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = ci2 + cr5; |
| 3381 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3] = cr3 - ci4; |
| 3382 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 + 1] = ci3 + cr4; |
| 3383 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx4] = cr3 + ci4; |
| 3384 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4 + 1] = ci3 - cr4; |
| 3385 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx5] = cr2 + ci5; |
| 3386 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx5 + 1] = ci2 - cr5; |
| 3387 | } | |
| 3388 | } else { | |
| 3389 |
2
1. passf5 : changed conditional boundary → NO_COVERAGE 2. passf5 : negated conditional → NO_COVERAGE |
for (int k = 1; k <= l1; k++) { |
| 3390 |
5
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced integer multiplication with division → NO_COVERAGE 3. passf5 : Replaced integer subtraction with addition → NO_COVERAGE 4. passf5 : Replaced integer multiplication with division → NO_COVERAGE 5. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = in_off + 1 + (k * 5 - 4) * ido; |
| 3391 |
3
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE 2. passf5 : Replaced integer multiplication with division → NO_COVERAGE 3. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = out_off + (k - 1) * ido; |
| 3392 |
3
1. passf5 : changed conditional boundary → NO_COVERAGE 2. passf5 : Replaced integer subtraction with addition → NO_COVERAGE 3. passf5 : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido - 1; i += 2) { |
| 3393 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = i + idx1; |
| 3394 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = iidx1 + ido; |
| 3395 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
int iidx3 = iidx1 - ido; |
| 3396 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx4 = iidx2 + ido; |
| 3397 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx5 = iidx4 + ido; |
| 3398 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 3399 | double i1r = in[iidx1]; | |
| 3400 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 3401 | double i2r = in[iidx2]; | |
| 3402 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i3i = in[iidx3 - 1]; |
| 3403 | double i3r = in[iidx3]; | |
| 3404 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i4i = in[iidx4 - 1]; |
| 3405 | double i4r = in[iidx4]; | |
| 3406 |
1
1. passf5 : Replaced integer subtraction with addition → NO_COVERAGE |
double i5i = in[iidx5 - 1]; |
| 3407 | double i5r = in[iidx5]; | |
| 3408 | ||
| 3409 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
ti5 = i1r - i5r; |
| 3410 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti2 = i1r + i5r; |
| 3411 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
ti4 = i2r - i4r; |
| 3412 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ti3 = i2r + i4r; |
| 3413 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
tr5 = i1i - i5i; |
| 3414 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr2 = i1i + i5i; |
| 3415 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
tr4 = i2i - i4i; |
| 3416 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
tr3 = i2i + i4i; |
| 3417 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr2 = i3i + tr11 * tr2 + tr12 * tr3; |
| 3418 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci2 = i3r + tr11 * ti2 + tr12 * ti3; |
| 3419 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
cr3 = i3i + tr12 * tr2 + tr11 * tr3; |
| 3420 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
ci3 = i3r + tr12 * ti2 + tr11 * ti3; |
| 3421 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
cr5 = isign * (ti11 * tr5 + ti12 * tr4); |
| 3422 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
ci5 = isign * (ti11 * ti5 + ti12 * ti4); |
| 3423 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
cr4 = isign * (ti12 * tr5 - ti11 * tr4); |
| 3424 |
4
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE 4. passf5 : Replaced double multiplication with division → NO_COVERAGE |
ci4 = isign * (ti12 * ti5 - ti11 * ti4); |
| 3425 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
dr3 = cr3 - ci4; |
| 3426 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr4 = cr3 + ci4; |
| 3427 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
di3 = ci3 + cr4; |
| 3428 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
di4 = ci3 - cr4; |
| 3429 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
dr5 = cr2 + ci5; |
| 3430 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
dr2 = cr2 - ci5; |
| 3431 |
1
1. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
di5 = ci2 - cr5; |
| 3432 |
1
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
di2 = ci2 + cr5; |
| 3433 | ||
| 3434 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx1 = i + iw1; |
| 3435 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx2 = i + iw2; |
| 3436 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx3 = i + iw3; |
| 3437 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int widx4 = i + iw4; |
| 3438 | double w1r = wtable[widx1]; | |
| 3439 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE |
double w1i = isign * wtable[widx1 + 1]; |
| 3440 | double w2r = wtable[widx2]; | |
| 3441 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE |
double w2i = isign * wtable[widx2 + 1]; |
| 3442 | double w3r = wtable[widx3]; | |
| 3443 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE |
double w3i = isign * wtable[widx3 + 1]; |
| 3444 | double w4r = wtable[widx4]; | |
| 3445 |
2
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE |
double w4i = isign * wtable[widx4 + 1]; |
| 3446 | ||
| 3447 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = i + idx2; |
| 3448 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = oidx1 + idx0; |
| 3449 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx3 = oidx2 + idx0; |
| 3450 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx4 = oidx3 + idx0; |
| 3451 |
1
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx5 = oidx4 + idx0; |
| 3452 |
2
1. passf5 : Replaced double addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i3i + tr2 + tr3; |
| 3453 |
3
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double addition with subtraction → NO_COVERAGE 3. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + 1] = i3r + ti2 + ti3; |
| 3454 |
3
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = w1r * dr2 - w1i * di2; |
| 3455 |
4
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 + 1] = w1r * di2 + w1i * dr2; |
| 3456 |
3
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx3] = w2r * dr3 - w2i * di3; |
| 3457 |
4
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx3 + 1] = w2r * di3 + w2i * dr3; |
| 3458 |
3
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx4] = w3r * dr4 - w3i * di4; |
| 3459 |
4
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx4 + 1] = w3r * di4 + w3i * dr4; |
| 3460 |
3
1. passf5 : Replaced double multiplication with division → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx5] = w4r * dr5 - w4i * di5; |
| 3461 |
4
1. passf5 : Replaced integer addition with subtraction → NO_COVERAGE 2. passf5 : Replaced double multiplication with division → NO_COVERAGE 3. passf5 : Replaced double multiplication with division → NO_COVERAGE 4. passf5 : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx5 + 1] = w4r * di5 + w4i * dr5; |
| 3462 | } | |
| 3463 | } | |
| 3464 | } | |
| 3465 | } | |
| 3466 | ||
| 3467 | /*---------------------------------------------------------------------- | |
| 3468 | passfg: Complex FFT's forward/backward processing of general factor; | |
| 3469 | isign is +1 for backward and -1 for forward transforms | |
| 3470 | ----------------------------------------------------------------------*/ | |
| 3471 | void passfg(final int nac[], final int ido, final int ip, final int l1, final int idl1, final double in[], final int in_off, final double out[], final int out_off, final int offset, final int isign) { | |
| 3472 | int idij, idlj, idot, ipph, l, jc, lc, idj, idl, inc, idp; | |
| 3473 | double w1r, w1i, w2i, w2r; | |
| 3474 | int iw1; | |
| 3475 | ||
| 3476 | iw1 = offset; | |
| 3477 |
1
1. passfg : Replaced integer division with multiplication → NO_COVERAGE |
idot = ido / 2; |
| 3478 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer division with multiplication → NO_COVERAGE |
ipph = (ip + 1) / 2; |
| 3479 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
idp = ip * ido; |
| 3480 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
if (ido >= l1) { |
| 3481 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 3482 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 3483 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * ido; |
| 3484 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * ido; |
| 3485 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3486 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx3 = k * ido; |
| 3487 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = idx3 + idx1 * l1; |
| 3488 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = idx3 + idx2 * l1; |
| 3489 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx6 = idx3 * ip; |
| 3490 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 3491 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i; |
| 3492 |
3
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[in_off + i + idx1 + idx6]; |
| 3493 |
3
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[in_off + i + idx2 + idx6]; |
| 3494 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1 + idx4] = i1r + i2r; |
| 3495 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 + idx5] = i1r - i2r; |
| 3496 | } | |
| 3497 | } | |
| 3498 | } | |
| 3499 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3500 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt1 = k * ido; |
| 3501 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt2 = idxt1 * ip; |
| 3502 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 3503 |
4
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced integer addition with subtraction → NO_COVERAGE 4. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
out[out_off + i + idxt1] = in[in_off + i + idxt2]; |
| 3504 | } | |
| 3505 | } | |
| 3506 | } else { | |
| 3507 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 3508 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 3509 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt1 = j * l1 * ido; |
| 3510 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt2 = jc * l1 * ido; |
| 3511 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt3 = j * ido; |
| 3512 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt4 = jc * ido; |
| 3513 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 3514 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3515 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 3516 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = idx1 * ip; |
| 3517 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = out_off + i; |
| 3518 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + i; |
| 3519 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
double i1r = in[idx4 + idxt3 + idx2]; |
| 3520 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
double i2r = in[idx4 + idxt4 + idx2]; |
| 3521 |
3
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx3 + idx1 + idxt1] = i1r + i2r; |
| 3522 |
3
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double subtraction with addition → NO_COVERAGE |
out[idx3 + idx1 + idxt2] = i1r - i2r; |
| 3523 | } | |
| 3524 | } | |
| 3525 | } | |
| 3526 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 0; i < ido; i++) { |
| 3527 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3528 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = k * ido; |
| 3529 |
5
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced integer addition with subtraction → NO_COVERAGE 4. passfg : Replaced integer multiplication with division → NO_COVERAGE 5. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
out[out_off + i + idx1] = in[in_off + i + idx1 * ip]; |
| 3530 | } | |
| 3531 | } | |
| 3532 | } | |
| 3533 | ||
| 3534 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
idl = 2 - ido; |
| 3535 | inc = 0; | |
| 3536 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt0 = (ip - 1) * idl1; |
| 3537 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (l = 1; l < ipph; l++) { |
| 3538 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
lc = ip - l; |
| 3539 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
idl += ido; |
| 3540 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt1 = l * idl1; |
| 3541 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt2 = lc * idl1; |
| 3542 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idxt3 = idl + iw1; |
| 3543 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable[idxt3 - 2]; |
| 3544 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE |
w1i = isign * wtable[idxt3 - 1]; |
| 3545 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 3546 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = in_off + ik; |
| 3547 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = out_off + ik; |
| 3548 |
4
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE 4. passfg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx1 + idxt1] = out[idx2] + w1r * out[idx2 + idl1]; |
| 3549 |
3
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE |
in[idx1 + idxt2] = w1i * out[idx2 + idxt0]; |
| 3550 | } | |
| 3551 | idlj = idl; | |
| 3552 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
inc += ido; |
| 3553 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 2; j < ipph; j++) { |
| 3554 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 3555 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
idlj += inc; |
| 3556 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
if (idlj > idp) |
| 3557 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
idlj -= idp; |
| 3558 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idxt4 = idlj + iw1; |
| 3559 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
w2r = wtable[idxt4 - 2]; |
| 3560 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE |
w2i = isign * wtable[idxt4 - 1]; |
| 3561 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt5 = j * idl1; |
| 3562 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt6 = jc * idl1; |
| 3563 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 3564 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = in_off + ik; |
| 3565 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = out_off + ik; |
| 3566 |
4
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE 4. passfg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx1 + idxt1] += w2r * out[idx2 + idxt5]; |
| 3567 |
4
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE 4. passfg : Replaced double addition with subtraction → NO_COVERAGE |
in[idx1 + idxt2] += w2i * out[idx2 + idxt6]; |
| 3568 | } | |
| 3569 | } | |
| 3570 | } | |
| 3571 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 3572 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idxt1 = j * idl1; |
| 3573 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int ik = 0; ik < idl1; ik++) { |
| 3574 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = out_off + ik; |
| 3575 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced double addition with subtraction → NO_COVERAGE |
out[idx1] += out[idx1 + idxt1]; |
| 3576 | } | |
| 3577 | } | |
| 3578 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ipph; j++) { |
| 3579 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
jc = ip - j; |
| 3580 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * idl1; |
| 3581 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = jc * idl1; |
| 3582 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int ik = 1; ik < idl1; ik += 2) { |
| 3583 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = out_off + ik; |
| 3584 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = in_off + ik; |
| 3585 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx4 + idx1; |
| 3586 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx2 = idx4 + idx2; |
| 3587 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
double i1i = in[iidx1 - 1]; |
| 3588 | double i1r = in[iidx1]; | |
| 3589 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
double i2i = in[iidx2 - 1]; |
| 3590 | double i2r = in[iidx2]; | |
| 3591 | ||
| 3592 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx3 + idx1; |
| 3593 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx2 = idx3 + idx2; |
| 3594 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx1 - 1] = i1i - i2r; |
| 3595 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx2 - 1] = i1i + i2r; |
| 3596 |
1
1. passfg : Replaced double addition with subtraction → NO_COVERAGE |
out[oidx1] = i1r + i2i; |
| 3597 |
1
1. passfg : Replaced double subtraction with addition → NO_COVERAGE |
out[oidx2] = i1r - i2i; |
| 3598 | } | |
| 3599 | } | |
| 3600 | nac[0] = 1; | |
| 3601 |
1
1. passfg : negated conditional → NO_COVERAGE |
if (ido == 2) |
| 3602 | return; | |
| 3603 | nac[0] = 0; | |
| 3604 |
1
1. passfg : removed call to java/lang/System::arraycopy → NO_COVERAGE |
System.arraycopy(out, out_off, in, in_off, idl1); |
| 3605 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx0 = l1 * ido; |
| 3606 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 3607 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * idx0; |
| 3608 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3609 |
1
1. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx2 = k * ido; |
| 3610 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + idx2 + idx1; |
| 3611 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + idx2 + idx1; |
| 3612 | in[iidx1] = out[oidx1]; | |
| 3613 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
in[iidx1 + 1] = out[oidx1 + 1]; |
| 3614 | } | |
| 3615 | } | |
| 3616 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
if (idot <= l1) { |
| 3617 | idij = 0; | |
| 3618 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 3619 |
1
1. passfg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 3620 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 3621 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 3; i < ido; i += 2) { |
| 3622 |
1
1. passfg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 3623 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
int idx2 = idij + iw1 - 1; |
| 3624 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable[idx2 - 1]; |
| 3625 |
1
1. passfg : Replaced double multiplication with division → NO_COVERAGE |
w1i = isign * wtable[idx2]; |
| 3626 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = in_off + i; |
| 3627 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx4 = out_off + i; |
| 3628 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3629 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx5 = k * ido + idx1; |
| 3630 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = idx3 + idx5; |
| 3631 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = idx4 + idx5; |
| 3632 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 3633 | double o1r = out[oidx1]; | |
| 3634 |
4
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE 4. passfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx1 - 1] = w1r * o1i - w1i * o1r; |
| 3635 |
3
1. passfg : Replaced double multiplication with division → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE 3. passfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = w1r * o1r + w1i * o1i; |
| 3636 | } | |
| 3637 | } | |
| 3638 | } | |
| 3639 | } else { | |
| 3640 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
idj = 2 - ido; |
| 3641 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int j = 1; j < ip; j++) { |
| 3642 |
1
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
idj += ido; |
| 3643 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer multiplication with division → NO_COVERAGE |
int idx1 = j * l1 * ido; |
| 3644 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int k = 0; k < l1; k++) { |
| 3645 | idij = idj; | |
| 3646 |
2
1. passfg : Replaced integer multiplication with division → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx3 = k * ido + idx1; |
| 3647 |
2
1. passfg : changed conditional boundary → NO_COVERAGE 2. passfg : negated conditional → NO_COVERAGE |
for (int i = 3; i < ido; i += 2) { |
| 3648 |
1
1. passfg : Changed increment from 2 to -2 → NO_COVERAGE |
idij += 2; |
| 3649 |
2
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = idij - 1 + iw1; |
| 3650 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
w1r = wtable[idx2 - 1]; |
| 3651 |
1
1. passfg : Replaced double multiplication with division → NO_COVERAGE |
w1i = isign * wtable[idx2]; |
| 3652 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int iidx1 = in_off + i + idx3; |
| 3653 |
2
1. passfg : Replaced integer addition with subtraction → NO_COVERAGE 2. passfg : Replaced integer addition with subtraction → NO_COVERAGE |
int oidx1 = out_off + i + idx3; |
| 3654 |
1
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE |
double o1i = out[oidx1 - 1]; |
| 3655 | double o1r = out[oidx1]; | |
| 3656 |
4
1. passfg : Replaced integer subtraction with addition → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE 3. passfg : Replaced double multiplication with division → NO_COVERAGE 4. passfg : Replaced double subtraction with addition → NO_COVERAGE |
in[iidx1 - 1] = w1r * o1i - w1i * o1r; |
| 3657 |
3
1. passfg : Replaced double multiplication with division → NO_COVERAGE 2. passfg : Replaced double multiplication with division → NO_COVERAGE 3. passfg : Replaced double addition with subtraction → NO_COVERAGE |
in[iidx1] = w1r * o1r + w1i * o1i; |
| 3658 | } | |
| 3659 | } | |
| 3660 | } | |
| 3661 | } | |
| 3662 | } | |
| 3663 | ||
| 3664 | private void cftfsub(int n, double[] a, int offa, int[] ip, int nw, double[] w) { | |
| 3665 |
2
1. cftfsub : changed conditional boundary → NO_COVERAGE 2. cftfsub : negated conditional → NO_COVERAGE |
if (n > 8) { |
| 3666 |
2
1. cftfsub : changed conditional boundary → NO_COVERAGE 2. cftfsub : negated conditional → NO_COVERAGE |
if (n > 32) { |
| 3667 |
3
1. cftfsub : Replaced Shift Right with Shift Left → NO_COVERAGE 2. cftfsub : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfsub : removed call to mikera/matrixx/algo/FFT::cftf1st → NO_COVERAGE |
cftf1st(n, a, offa, w, nw - (n >> 2)); |
| 3668 |
2
1. cftfsub : changed conditional boundary → NO_COVERAGE 2. cftfsub : negated conditional → NO_COVERAGE |
if (n > 512) { |
| 3669 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftrec4 → NO_COVERAGE |
cftrec4(n, a, offa, nw, w); |
| 3670 |
2
1. cftfsub : changed conditional boundary → NO_COVERAGE 2. cftfsub : negated conditional → NO_COVERAGE |
} else if (n > 128) { |
| 3671 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftleaf → NO_COVERAGE |
cftleaf(n, 1, a, offa, nw, w); |
| 3672 | } else { | |
| 3673 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftfx41 → NO_COVERAGE |
cftfx41(n, a, offa, nw, w); |
| 3674 | } | |
| 3675 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::bitrv2 → NO_COVERAGE |
bitrv2(n, ip, a, offa); |
| 3676 |
1
1. cftfsub : negated conditional → NO_COVERAGE |
} else if (n == 32) { |
| 3677 |
2
1. cftfsub : Replaced integer subtraction with addition → NO_COVERAGE 2. cftfsub : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa, w, nw - 8); |
| 3678 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::bitrv216 → NO_COVERAGE |
bitrv216(a, offa); |
| 3679 | } else { | |
| 3680 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa, w, 0); |
| 3681 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::bitrv208 → NO_COVERAGE |
bitrv208(a, offa); |
| 3682 | } | |
| 3683 |
1
1. cftfsub : negated conditional → NO_COVERAGE |
} else if (n == 8) { |
| 3684 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftf040 → NO_COVERAGE |
cftf040(a, offa); |
| 3685 |
1
1. cftfsub : negated conditional → NO_COVERAGE |
} else if (n == 4) { |
| 3686 |
1
1. cftfsub : removed call to mikera/matrixx/algo/FFT::cftxb020 → NO_COVERAGE |
cftxb020(a, offa); |
| 3687 | } | |
| 3688 | } | |
| 3689 | ||
| 3690 | private void cftbsub(int n, double[] a, int offa, int[] ip, int nw, double[] w) { | |
| 3691 |
2
1. cftbsub : changed conditional boundary → NO_COVERAGE 2. cftbsub : negated conditional → NO_COVERAGE |
if (n > 8) { |
| 3692 |
2
1. cftbsub : changed conditional boundary → NO_COVERAGE 2. cftbsub : negated conditional → NO_COVERAGE |
if (n > 32) { |
| 3693 |
3
1. cftbsub : Replaced Shift Right with Shift Left → NO_COVERAGE 2. cftbsub : Replaced integer subtraction with addition → NO_COVERAGE 3. cftbsub : removed call to mikera/matrixx/algo/FFT::cftb1st → NO_COVERAGE |
cftb1st(n, a, offa, w, nw - (n >> 2)); |
| 3694 |
2
1. cftbsub : changed conditional boundary → NO_COVERAGE 2. cftbsub : negated conditional → NO_COVERAGE |
if (n > 512) { |
| 3695 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftrec4 → NO_COVERAGE |
cftrec4(n, a, offa, nw, w); |
| 3696 |
2
1. cftbsub : changed conditional boundary → NO_COVERAGE 2. cftbsub : negated conditional → NO_COVERAGE |
} else if (n > 128) { |
| 3697 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftleaf → NO_COVERAGE |
cftleaf(n, 1, a, offa, nw, w); |
| 3698 | } else { | |
| 3699 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftfx41 → NO_COVERAGE |
cftfx41(n, a, offa, nw, w); |
| 3700 | } | |
| 3701 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::bitrv2conj → NO_COVERAGE |
bitrv2conj(n, ip, a, offa); |
| 3702 |
1
1. cftbsub : negated conditional → NO_COVERAGE |
} else if (n == 32) { |
| 3703 |
2
1. cftbsub : Replaced integer subtraction with addition → NO_COVERAGE 2. cftbsub : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa, w, nw - 8); |
| 3704 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::bitrv216neg → NO_COVERAGE |
bitrv216neg(a, offa); |
| 3705 | } else { | |
| 3706 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa, w, 0); |
| 3707 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::bitrv208neg → NO_COVERAGE |
bitrv208neg(a, offa); |
| 3708 | } | |
| 3709 |
1
1. cftbsub : negated conditional → NO_COVERAGE |
} else if (n == 8) { |
| 3710 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftb040 → NO_COVERAGE |
cftb040(a, offa); |
| 3711 |
1
1. cftbsub : negated conditional → NO_COVERAGE |
} else if (n == 4) { |
| 3712 |
1
1. cftbsub : removed call to mikera/matrixx/algo/FFT::cftxb020 → NO_COVERAGE |
cftxb020(a, offa); |
| 3713 | } | |
| 3714 | } | |
| 3715 | ||
| 3716 | private void bitrv2(int n, int[] ip, double[] a, int offa) { | |
| 3717 | int j1, k1, l, m, nh, nm; | |
| 3718 | double xr, xi, yr, yi; | |
| 3719 | int idx0, idx1, idx2; | |
| 3720 | ||
| 3721 | m = 1; | |
| 3722 |
4
1. bitrv2 : changed conditional boundary → NO_COVERAGE 2. bitrv2 : Replaced Shift Right with Shift Left → NO_COVERAGE 3. bitrv2 : Replaced Shift Right with Shift Left → NO_COVERAGE 4. bitrv2 : negated conditional → NO_COVERAGE |
for (l = n >> 2; l > 8; l >>= 2) { |
| 3723 |
1
1. bitrv2 : Replaced Shift Left with Shift Right → NO_COVERAGE |
m <<= 1; |
| 3724 | } | |
| 3725 |
1
1. bitrv2 : Replaced Shift Right with Shift Left → NO_COVERAGE |
nh = n >> 1; |
| 3726 |
1
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE |
nm = 4 * m; |
| 3727 |
1
1. bitrv2 : negated conditional → NO_COVERAGE |
if (l == 8) { |
| 3728 |
2
1. bitrv2 : changed conditional boundary → NO_COVERAGE 2. bitrv2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < m; k++) { |
| 3729 |
1
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE |
idx0 = 4 * k; |
| 3730 |
2
1. bitrv2 : changed conditional boundary → NO_COVERAGE 2. bitrv2 : negated conditional → NO_COVERAGE |
for (int j = 0; j < k; j++) { |
| 3731 |
4
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 4. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = 4 * j + 2 * ip[m + k]; |
| 3732 |
3
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 3. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + 2 * ip[m + j]; |
| 3733 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3734 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3735 | xr = a[idx1]; | |
| 3736 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3737 | yr = a[idx2]; | |
| 3738 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3739 | a[idx1] = yr; | |
| 3740 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3741 | a[idx2] = xr; | |
| 3742 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3743 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3744 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 3745 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3746 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3747 | xr = a[idx1]; | |
| 3748 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3749 | yr = a[idx2]; | |
| 3750 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3751 | a[idx1] = yr; | |
| 3752 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3753 | a[idx2] = xr; | |
| 3754 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3755 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3756 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 3757 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3758 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3759 | xr = a[idx1]; | |
| 3760 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3761 | yr = a[idx2]; | |
| 3762 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3763 | a[idx1] = yr; | |
| 3764 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3765 | a[idx2] = xr; | |
| 3766 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3767 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3768 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 3769 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3770 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3771 | xr = a[idx1]; | |
| 3772 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3773 | yr = a[idx2]; | |
| 3774 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3775 | a[idx1] = yr; | |
| 3776 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3777 | a[idx2] = xr; | |
| 3778 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3779 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh; |
| 3780 |
1
1. bitrv2 : Changed increment from 2 to -2 → NO_COVERAGE |
k1 += 2; |
| 3781 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3782 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3783 | xr = a[idx1]; | |
| 3784 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3785 | yr = a[idx2]; | |
| 3786 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3787 | a[idx1] = yr; | |
| 3788 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3789 | a[idx2] = xr; | |
| 3790 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3791 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3792 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 3793 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3794 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3795 | xr = a[idx1]; | |
| 3796 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3797 | yr = a[idx2]; | |
| 3798 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3799 | a[idx1] = yr; | |
| 3800 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3801 | a[idx2] = xr; | |
| 3802 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3803 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3804 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 3805 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3806 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3807 | xr = a[idx1]; | |
| 3808 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3809 | yr = a[idx2]; | |
| 3810 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3811 | a[idx1] = yr; | |
| 3812 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3813 | a[idx2] = xr; | |
| 3814 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3815 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3816 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 3817 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3818 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3819 | xr = a[idx1]; | |
| 3820 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3821 | yr = a[idx2]; | |
| 3822 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3823 | a[idx1] = yr; | |
| 3824 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3825 | a[idx2] = xr; | |
| 3826 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3827 |
1
1. bitrv2 : Changed increment from 2 to -2 → NO_COVERAGE |
j1 += 2; |
| 3828 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 3829 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3830 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3831 | xr = a[idx1]; | |
| 3832 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3833 | yr = a[idx2]; | |
| 3834 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3835 | a[idx1] = yr; | |
| 3836 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3837 | a[idx2] = xr; | |
| 3838 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3839 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3840 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 3841 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3842 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3843 | xr = a[idx1]; | |
| 3844 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3845 | yr = a[idx2]; | |
| 3846 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3847 | a[idx1] = yr; | |
| 3848 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3849 | a[idx2] = xr; | |
| 3850 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3851 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3852 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 3853 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3854 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3855 | xr = a[idx1]; | |
| 3856 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3857 | yr = a[idx2]; | |
| 3858 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3859 | a[idx1] = yr; | |
| 3860 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3861 | a[idx2] = xr; | |
| 3862 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3863 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3864 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 3865 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3866 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3867 | xr = a[idx1]; | |
| 3868 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3869 | yr = a[idx2]; | |
| 3870 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3871 | a[idx1] = yr; | |
| 3872 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3873 | a[idx2] = xr; | |
| 3874 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3875 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh; |
| 3876 |
1
1. bitrv2 : Changed increment from -2 to 2 → NO_COVERAGE |
k1 -= 2; |
| 3877 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3878 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3879 | xr = a[idx1]; | |
| 3880 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3881 | yr = a[idx2]; | |
| 3882 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3883 | a[idx1] = yr; | |
| 3884 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3885 | a[idx2] = xr; | |
| 3886 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3887 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3888 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 3889 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3890 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3891 | xr = a[idx1]; | |
| 3892 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3893 | yr = a[idx2]; | |
| 3894 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3895 | a[idx1] = yr; | |
| 3896 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3897 | a[idx2] = xr; | |
| 3898 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3899 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3900 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 3901 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3902 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3903 | xr = a[idx1]; | |
| 3904 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3905 | yr = a[idx2]; | |
| 3906 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3907 | a[idx1] = yr; | |
| 3908 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3909 | a[idx2] = xr; | |
| 3910 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3911 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 3912 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 3913 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3914 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3915 | xr = a[idx1]; | |
| 3916 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3917 | yr = a[idx2]; | |
| 3918 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3919 | a[idx1] = yr; | |
| 3920 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3921 | a[idx2] = xr; | |
| 3922 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3923 | } | |
| 3924 |
3
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 3. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + 2 * ip[m + k]; |
| 3925 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = k1 + 2; |
| 3926 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 3927 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3928 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3929 | xr = a[idx1]; | |
| 3930 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3931 | yr = a[idx2]; | |
| 3932 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3933 | a[idx1] = yr; | |
| 3934 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3935 | a[idx2] = xr; | |
| 3936 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3937 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3938 |
2
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 3939 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3940 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3941 | xr = a[idx1]; | |
| 3942 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3943 | yr = a[idx2]; | |
| 3944 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3945 | a[idx1] = yr; | |
| 3946 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3947 | a[idx2] = xr; | |
| 3948 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3949 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 3950 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 3951 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3952 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3953 | xr = a[idx1]; | |
| 3954 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3955 | yr = a[idx2]; | |
| 3956 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3957 | a[idx1] = yr; | |
| 3958 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3959 | a[idx2] = xr; | |
| 3960 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3961 |
1
1. bitrv2 : Changed increment from -2 to 2 → NO_COVERAGE |
j1 -= 2; |
| 3962 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nh; |
| 3963 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3964 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3965 | xr = a[idx1]; | |
| 3966 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3967 | yr = a[idx2]; | |
| 3968 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3969 | a[idx1] = yr; | |
| 3970 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3971 | a[idx2] = xr; | |
| 3972 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3973 |
2
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh + 2; |
| 3974 |
2
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh + 2; |
| 3975 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3976 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3977 | xr = a[idx1]; | |
| 3978 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3979 | yr = a[idx2]; | |
| 3980 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3981 | a[idx1] = yr; | |
| 3982 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3983 | a[idx2] = xr; | |
| 3984 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3985 |
2
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh - nm; |
| 3986 |
3
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm - 2; |
| 3987 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 3988 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 3989 | xr = a[idx1]; | |
| 3990 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 3991 | yr = a[idx2]; | |
| 3992 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 3993 | a[idx1] = yr; | |
| 3994 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 3995 | a[idx2] = xr; | |
| 3996 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 3997 | } | |
| 3998 | } else { | |
| 3999 |
2
1. bitrv2 : changed conditional boundary → NO_COVERAGE 2. bitrv2 : negated conditional → NO_COVERAGE |
for (int k = 0; k < m; k++) { |
| 4000 |
1
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE |
idx0 = 4 * k; |
| 4001 |
2
1. bitrv2 : changed conditional boundary → NO_COVERAGE 2. bitrv2 : negated conditional → NO_COVERAGE |
for (int j = 0; j < k; j++) { |
| 4002 |
3
1. bitrv2 : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = 4 * j + ip[m + k]; |
| 4003 |
2
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + ip[m + j]; |
| 4004 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4005 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4006 | xr = a[idx1]; | |
| 4007 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4008 | yr = a[idx2]; | |
| 4009 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4010 | a[idx1] = yr; | |
| 4011 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4012 | a[idx2] = xr; | |
| 4013 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4014 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4015 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4016 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4017 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4018 | xr = a[idx1]; | |
| 4019 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4020 | yr = a[idx2]; | |
| 4021 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4022 | a[idx1] = yr; | |
| 4023 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4024 | a[idx2] = xr; | |
| 4025 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4026 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh; |
| 4027 |
1
1. bitrv2 : Changed increment from 2 to -2 → NO_COVERAGE |
k1 += 2; |
| 4028 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4029 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4030 | xr = a[idx1]; | |
| 4031 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4032 | yr = a[idx2]; | |
| 4033 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4034 | a[idx1] = yr; | |
| 4035 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4036 | a[idx2] = xr; | |
| 4037 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4038 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4039 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4040 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4041 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4042 | xr = a[idx1]; | |
| 4043 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4044 | yr = a[idx2]; | |
| 4045 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4046 | a[idx1] = yr; | |
| 4047 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4048 | a[idx2] = xr; | |
| 4049 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4050 |
1
1. bitrv2 : Changed increment from 2 to -2 → NO_COVERAGE |
j1 += 2; |
| 4051 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4052 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4053 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4054 | xr = a[idx1]; | |
| 4055 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4056 | yr = a[idx2]; | |
| 4057 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4058 | a[idx1] = yr; | |
| 4059 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4060 | a[idx2] = xr; | |
| 4061 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4062 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4063 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4064 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4065 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4066 | xr = a[idx1]; | |
| 4067 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4068 | yr = a[idx2]; | |
| 4069 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4070 | a[idx1] = yr; | |
| 4071 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4072 | a[idx2] = xr; | |
| 4073 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4074 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh; |
| 4075 |
1
1. bitrv2 : Changed increment from -2 to 2 → NO_COVERAGE |
k1 -= 2; |
| 4076 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4077 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4078 | xr = a[idx1]; | |
| 4079 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4080 | yr = a[idx2]; | |
| 4081 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4082 | a[idx1] = yr; | |
| 4083 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4084 | a[idx2] = xr; | |
| 4085 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4086 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4087 |
1
1. bitrv2 : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4088 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4089 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4090 | xr = a[idx1]; | |
| 4091 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4092 | yr = a[idx2]; | |
| 4093 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4094 | a[idx1] = yr; | |
| 4095 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4096 | a[idx2] = xr; | |
| 4097 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4098 | } | |
| 4099 |
2
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + ip[m + k]; |
| 4100 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = k1 + 2; |
| 4101 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4102 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4103 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4104 | xr = a[idx1]; | |
| 4105 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4106 | yr = a[idx2]; | |
| 4107 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4108 | a[idx1] = yr; | |
| 4109 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4110 | a[idx2] = xr; | |
| 4111 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4112 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4113 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4114 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4115 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4116 | xr = a[idx1]; | |
| 4117 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1]; |
| 4118 | yr = a[idx2]; | |
| 4119 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
yi = a[idx2 + 1]; |
| 4120 | a[idx1] = yr; | |
| 4121 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4122 | a[idx2] = xr; | |
| 4123 |
1
1. bitrv2 : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4124 | } | |
| 4125 | } | |
| 4126 | } | |
| 4127 | ||
| 4128 | private void bitrv2conj(int n, int[] ip, double[] a, int offa) { | |
| 4129 | int j1, k1, l, m, nh, nm; | |
| 4130 | double xr, xi, yr, yi; | |
| 4131 | int idx0, idx1, idx2; | |
| 4132 | ||
| 4133 | m = 1; | |
| 4134 |
4
1. bitrv2conj : changed conditional boundary → NO_COVERAGE 2. bitrv2conj : Replaced Shift Right with Shift Left → NO_COVERAGE 3. bitrv2conj : Replaced Shift Right with Shift Left → NO_COVERAGE 4. bitrv2conj : negated conditional → NO_COVERAGE |
for (l = n >> 2; l > 8; l >>= 2) { |
| 4135 |
1
1. bitrv2conj : Replaced Shift Left with Shift Right → NO_COVERAGE |
m <<= 1; |
| 4136 | } | |
| 4137 |
1
1. bitrv2conj : Replaced Shift Right with Shift Left → NO_COVERAGE |
nh = n >> 1; |
| 4138 |
1
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE |
nm = 4 * m; |
| 4139 |
1
1. bitrv2conj : negated conditional → NO_COVERAGE |
if (l == 8) { |
| 4140 |
2
1. bitrv2conj : changed conditional boundary → NO_COVERAGE 2. bitrv2conj : negated conditional → NO_COVERAGE |
for (int k = 0; k < m; k++) { |
| 4141 |
1
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE |
idx0 = 4 * k; |
| 4142 |
2
1. bitrv2conj : changed conditional boundary → NO_COVERAGE 2. bitrv2conj : negated conditional → NO_COVERAGE |
for (int j = 0; j < k; j++) { |
| 4143 |
4
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 4. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = 4 * j + 2 * ip[m + k]; |
| 4144 |
3
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + 2 * ip[m + j]; |
| 4145 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4146 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4147 | xr = a[idx1]; | |
| 4148 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4149 | yr = a[idx2]; | |
| 4150 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4151 | a[idx1] = yr; | |
| 4152 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4153 | a[idx2] = xr; | |
| 4154 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4155 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4156 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 4157 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4158 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4159 | xr = a[idx1]; | |
| 4160 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4161 | yr = a[idx2]; | |
| 4162 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4163 | a[idx1] = yr; | |
| 4164 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4165 | a[idx2] = xr; | |
| 4166 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4167 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4168 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4169 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4170 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4171 | xr = a[idx1]; | |
| 4172 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4173 | yr = a[idx2]; | |
| 4174 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4175 | a[idx1] = yr; | |
| 4176 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4177 | a[idx2] = xr; | |
| 4178 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4179 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4180 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 4181 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4182 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4183 | xr = a[idx1]; | |
| 4184 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4185 | yr = a[idx2]; | |
| 4186 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4187 | a[idx1] = yr; | |
| 4188 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4189 | a[idx2] = xr; | |
| 4190 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4191 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh; |
| 4192 |
1
1. bitrv2conj : Changed increment from 2 to -2 → NO_COVERAGE |
k1 += 2; |
| 4193 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4194 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4195 | xr = a[idx1]; | |
| 4196 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4197 | yr = a[idx2]; | |
| 4198 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4199 | a[idx1] = yr; | |
| 4200 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4201 | a[idx2] = xr; | |
| 4202 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4203 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4204 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 4205 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4206 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4207 | xr = a[idx1]; | |
| 4208 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4209 | yr = a[idx2]; | |
| 4210 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4211 | a[idx1] = yr; | |
| 4212 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4213 | a[idx2] = xr; | |
| 4214 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4215 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4216 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4217 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4218 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4219 | xr = a[idx1]; | |
| 4220 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4221 | yr = a[idx2]; | |
| 4222 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4223 | a[idx1] = yr; | |
| 4224 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4225 | a[idx2] = xr; | |
| 4226 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4227 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4228 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 4229 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4230 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4231 | xr = a[idx1]; | |
| 4232 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4233 | yr = a[idx2]; | |
| 4234 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4235 | a[idx1] = yr; | |
| 4236 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4237 | a[idx2] = xr; | |
| 4238 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4239 |
1
1. bitrv2conj : Changed increment from 2 to -2 → NO_COVERAGE |
j1 += 2; |
| 4240 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4241 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4242 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4243 | xr = a[idx1]; | |
| 4244 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4245 | yr = a[idx2]; | |
| 4246 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4247 | a[idx1] = yr; | |
| 4248 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4249 | a[idx2] = xr; | |
| 4250 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4251 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4252 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 4253 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4254 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4255 | xr = a[idx1]; | |
| 4256 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4257 | yr = a[idx2]; | |
| 4258 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4259 | a[idx1] = yr; | |
| 4260 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4261 | a[idx2] = xr; | |
| 4262 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4263 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4264 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4265 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4266 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4267 | xr = a[idx1]; | |
| 4268 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4269 | yr = a[idx2]; | |
| 4270 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4271 | a[idx1] = yr; | |
| 4272 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4273 | a[idx2] = xr; | |
| 4274 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4275 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4276 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 4277 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4278 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4279 | xr = a[idx1]; | |
| 4280 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4281 | yr = a[idx2]; | |
| 4282 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4283 | a[idx1] = yr; | |
| 4284 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4285 | a[idx2] = xr; | |
| 4286 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4287 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh; |
| 4288 |
1
1. bitrv2conj : Changed increment from -2 to 2 → NO_COVERAGE |
k1 -= 2; |
| 4289 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4290 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4291 | xr = a[idx1]; | |
| 4292 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4293 | yr = a[idx2]; | |
| 4294 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4295 | a[idx1] = yr; | |
| 4296 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4297 | a[idx2] = xr; | |
| 4298 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4299 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4300 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 4301 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4302 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4303 | xr = a[idx1]; | |
| 4304 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4305 | yr = a[idx2]; | |
| 4306 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4307 | a[idx1] = yr; | |
| 4308 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4309 | a[idx2] = xr; | |
| 4310 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4311 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4312 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4313 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4314 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4315 | xr = a[idx1]; | |
| 4316 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4317 | yr = a[idx2]; | |
| 4318 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4319 | a[idx1] = yr; | |
| 4320 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4321 | a[idx2] = xr; | |
| 4322 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4323 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4324 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= 2 * nm; |
| 4325 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4326 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4327 | xr = a[idx1]; | |
| 4328 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4329 | yr = a[idx2]; | |
| 4330 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4331 | a[idx1] = yr; | |
| 4332 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4333 | a[idx2] = xr; | |
| 4334 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4335 | } | |
| 4336 |
3
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + 2 * ip[m + k]; |
| 4337 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = k1 + 2; |
| 4338 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4339 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4340 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4341 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = -a[idx1 - 1]; |
| 4342 | xr = a[idx1]; | |
| 4343 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4344 | yr = a[idx2]; | |
| 4345 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4346 | a[idx1] = yr; | |
| 4347 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4348 | a[idx2] = xr; | |
| 4349 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4350 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = -a[idx2 + 3]; |
| 4351 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4352 |
2
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm; |
| 4353 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4354 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4355 | xr = a[idx1]; | |
| 4356 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4357 | yr = a[idx2]; | |
| 4358 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4359 | a[idx1] = yr; | |
| 4360 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4361 | a[idx2] = xr; | |
| 4362 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4363 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4364 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4365 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4366 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4367 | xr = a[idx1]; | |
| 4368 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4369 | yr = a[idx2]; | |
| 4370 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4371 | a[idx1] = yr; | |
| 4372 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4373 | a[idx2] = xr; | |
| 4374 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4375 |
1
1. bitrv2conj : Changed increment from -2 to 2 → NO_COVERAGE |
j1 -= 2; |
| 4376 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nh; |
| 4377 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4378 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4379 | xr = a[idx1]; | |
| 4380 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4381 | yr = a[idx2]; | |
| 4382 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4383 | a[idx1] = yr; | |
| 4384 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4385 | a[idx2] = xr; | |
| 4386 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4387 |
2
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh + 2; |
| 4388 |
2
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh + 2; |
| 4389 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4390 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4391 | xr = a[idx1]; | |
| 4392 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4393 | yr = a[idx2]; | |
| 4394 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4395 | a[idx1] = yr; | |
| 4396 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4397 | a[idx2] = xr; | |
| 4398 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4399 |
2
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh - nm; |
| 4400 |
3
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += 2 * nm - 2; |
| 4401 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4402 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4403 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = -a[idx1 - 1]; |
| 4404 | xr = a[idx1]; | |
| 4405 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4406 | yr = a[idx2]; | |
| 4407 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4408 | a[idx1] = yr; | |
| 4409 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4410 | a[idx2] = xr; | |
| 4411 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4412 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = -a[idx2 + 3]; |
| 4413 | } | |
| 4414 | } else { | |
| 4415 |
2
1. bitrv2conj : changed conditional boundary → NO_COVERAGE 2. bitrv2conj : negated conditional → NO_COVERAGE |
for (int k = 0; k < m; k++) { |
| 4416 |
1
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE |
idx0 = 4 * k; |
| 4417 |
2
1. bitrv2conj : changed conditional boundary → NO_COVERAGE 2. bitrv2conj : negated conditional → NO_COVERAGE |
for (int j = 0; j < k; j++) { |
| 4418 |
3
1. bitrv2conj : Replaced integer multiplication with division → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = 4 * j + ip[m + k]; |
| 4419 |
2
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + ip[m + j]; |
| 4420 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4421 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4422 | xr = a[idx1]; | |
| 4423 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4424 | yr = a[idx2]; | |
| 4425 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4426 | a[idx1] = yr; | |
| 4427 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4428 | a[idx2] = xr; | |
| 4429 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4430 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4431 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4432 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4433 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4434 | xr = a[idx1]; | |
| 4435 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4436 | yr = a[idx2]; | |
| 4437 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4438 | a[idx1] = yr; | |
| 4439 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4440 | a[idx2] = xr; | |
| 4441 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4442 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nh; |
| 4443 |
1
1. bitrv2conj : Changed increment from 2 to -2 → NO_COVERAGE |
k1 += 2; |
| 4444 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4445 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4446 | xr = a[idx1]; | |
| 4447 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4448 | yr = a[idx2]; | |
| 4449 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4450 | a[idx1] = yr; | |
| 4451 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4452 | a[idx2] = xr; | |
| 4453 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4454 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4455 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4456 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4457 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4458 | xr = a[idx1]; | |
| 4459 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4460 | yr = a[idx2]; | |
| 4461 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4462 | a[idx1] = yr; | |
| 4463 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4464 | a[idx2] = xr; | |
| 4465 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4466 |
1
1. bitrv2conj : Changed increment from 2 to -2 → NO_COVERAGE |
j1 += 2; |
| 4467 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4468 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4469 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4470 | xr = a[idx1]; | |
| 4471 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4472 | yr = a[idx2]; | |
| 4473 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4474 | a[idx1] = yr; | |
| 4475 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4476 | a[idx2] = xr; | |
| 4477 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4478 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4479 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4480 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4481 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4482 | xr = a[idx1]; | |
| 4483 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4484 | yr = a[idx2]; | |
| 4485 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4486 | a[idx1] = yr; | |
| 4487 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4488 | a[idx2] = xr; | |
| 4489 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4490 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nh; |
| 4491 |
1
1. bitrv2conj : Changed increment from -2 to 2 → NO_COVERAGE |
k1 -= 2; |
| 4492 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4493 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4494 | xr = a[idx1]; | |
| 4495 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4496 | yr = a[idx2]; | |
| 4497 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4498 | a[idx1] = yr; | |
| 4499 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4500 | a[idx2] = xr; | |
| 4501 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4502 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
j1 -= nm; |
| 4503 |
1
1. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
k1 -= nm; |
| 4504 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4505 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4506 | xr = a[idx1]; | |
| 4507 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4508 | yr = a[idx2]; | |
| 4509 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4510 | a[idx1] = yr; | |
| 4511 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4512 | a[idx2] = xr; | |
| 4513 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4514 | } | |
| 4515 |
2
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 = idx0 + ip[m + k]; |
| 4516 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = k1 + 2; |
| 4517 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nh; |
| 4518 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4519 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4520 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = -a[idx1 - 1]; |
| 4521 | xr = a[idx1]; | |
| 4522 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4523 | yr = a[idx2]; | |
| 4524 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4525 | a[idx1] = yr; | |
| 4526 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4527 | a[idx2] = xr; | |
| 4528 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4529 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = -a[idx2 + 3]; |
| 4530 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
j1 += nm; |
| 4531 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
k1 += nm; |
| 4532 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4533 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k1; |
| 4534 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE 3. bitrv2conj : Replaced integer subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = -a[idx1 - 1]; |
| 4535 | xr = a[idx1]; | |
| 4536 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
xi = -a[idx1 + 1]; |
| 4537 | yr = a[idx2]; | |
| 4538 |
2
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
yi = -a[idx2 + 1]; |
| 4539 | a[idx1] = yr; | |
| 4540 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = yi; |
| 4541 | a[idx2] = xr; | |
| 4542 |
1
1. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = xi; |
| 4543 |
3
1. bitrv2conj : removed negation → NO_COVERAGE 2. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE 3. bitrv2conj : Replaced integer addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = -a[idx2 + 3]; |
| 4544 | } | |
| 4545 | } | |
| 4546 | } | |
| 4547 | ||
| 4548 | private void bitrv216(double[] a, int offa) { | |
| 4549 | double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, x5r, x5i, x7r, x7i, x8r, x8i, x10r, x10i, x11r, x11i, x12r, x12i, x13r, x13i, x14r, x14i; | |
| 4550 | ||
| 4551 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x1r = a[offa + 2]; |
| 4552 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x1i = a[offa + 3]; |
| 4553 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x2r = a[offa + 4]; |
| 4554 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x2i = a[offa + 5]; |
| 4555 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x3r = a[offa + 6]; |
| 4556 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x3i = a[offa + 7]; |
| 4557 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x4r = a[offa + 8]; |
| 4558 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x4i = a[offa + 9]; |
| 4559 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x5r = a[offa + 10]; |
| 4560 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x5i = a[offa + 11]; |
| 4561 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x7r = a[offa + 14]; |
| 4562 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x7i = a[offa + 15]; |
| 4563 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x8r = a[offa + 16]; |
| 4564 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x8i = a[offa + 17]; |
| 4565 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x10r = a[offa + 20]; |
| 4566 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x10i = a[offa + 21]; |
| 4567 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x11r = a[offa + 22]; |
| 4568 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x11i = a[offa + 23]; |
| 4569 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x12r = a[offa + 24]; |
| 4570 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x12i = a[offa + 25]; |
| 4571 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x13r = a[offa + 26]; |
| 4572 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x13i = a[offa + 27]; |
| 4573 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x14r = a[offa + 28]; |
| 4574 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
x14i = a[offa + 29]; |
| 4575 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x8r; |
| 4576 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x8i; |
| 4577 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 4] = x4r; |
| 4578 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 5] = x4i; |
| 4579 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 6] = x12r; |
| 4580 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 7] = x12i; |
| 4581 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 8] = x2r; |
| 4582 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 9] = x2i; |
| 4583 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 10] = x10r; |
| 4584 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 11] = x10i; |
| 4585 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 14] = x14r; |
| 4586 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 15] = x14i; |
| 4587 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 16] = x1r; |
| 4588 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 17] = x1i; |
| 4589 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 20] = x5r; |
| 4590 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 21] = x5i; |
| 4591 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 22] = x13r; |
| 4592 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 23] = x13i; |
| 4593 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 24] = x3r; |
| 4594 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 25] = x3i; |
| 4595 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 26] = x11r; |
| 4596 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 27] = x11i; |
| 4597 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 28] = x7r; |
| 4598 |
1
1. bitrv216 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 29] = x7i; |
| 4599 | } | |
| 4600 | ||
| 4601 | private void bitrv216neg(double[] a, int offa) { | |
| 4602 | double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, x5r, x5i, x6r, x6i, x7r, x7i, x8r, x8i, x9r, x9i, x10r, x10i, x11r, x11i, x12r, x12i, x13r, x13i, x14r, x14i, x15r, x15i; | |
| 4603 | ||
| 4604 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x1r = a[offa + 2]; |
| 4605 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x1i = a[offa + 3]; |
| 4606 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x2r = a[offa + 4]; |
| 4607 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x2i = a[offa + 5]; |
| 4608 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x3r = a[offa + 6]; |
| 4609 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x3i = a[offa + 7]; |
| 4610 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x4r = a[offa + 8]; |
| 4611 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x4i = a[offa + 9]; |
| 4612 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x5r = a[offa + 10]; |
| 4613 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x5i = a[offa + 11]; |
| 4614 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x6r = a[offa + 12]; |
| 4615 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x6i = a[offa + 13]; |
| 4616 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x7r = a[offa + 14]; |
| 4617 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x7i = a[offa + 15]; |
| 4618 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x8r = a[offa + 16]; |
| 4619 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x8i = a[offa + 17]; |
| 4620 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x9r = a[offa + 18]; |
| 4621 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x9i = a[offa + 19]; |
| 4622 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x10r = a[offa + 20]; |
| 4623 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x10i = a[offa + 21]; |
| 4624 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x11r = a[offa + 22]; |
| 4625 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x11i = a[offa + 23]; |
| 4626 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x12r = a[offa + 24]; |
| 4627 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x12i = a[offa + 25]; |
| 4628 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x13r = a[offa + 26]; |
| 4629 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x13i = a[offa + 27]; |
| 4630 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x14r = a[offa + 28]; |
| 4631 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x14i = a[offa + 29]; |
| 4632 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x15r = a[offa + 30]; |
| 4633 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
x15i = a[offa + 31]; |
| 4634 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x15r; |
| 4635 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x15i; |
| 4636 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 4] = x7r; |
| 4637 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 5] = x7i; |
| 4638 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 6] = x11r; |
| 4639 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 7] = x11i; |
| 4640 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 8] = x3r; |
| 4641 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 9] = x3i; |
| 4642 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 10] = x13r; |
| 4643 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 11] = x13i; |
| 4644 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 12] = x5r; |
| 4645 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 13] = x5i; |
| 4646 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 14] = x9r; |
| 4647 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 15] = x9i; |
| 4648 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 16] = x1r; |
| 4649 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 17] = x1i; |
| 4650 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 18] = x14r; |
| 4651 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 19] = x14i; |
| 4652 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 20] = x6r; |
| 4653 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 21] = x6i; |
| 4654 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 22] = x10r; |
| 4655 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 23] = x10i; |
| 4656 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 24] = x2r; |
| 4657 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 25] = x2i; |
| 4658 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 26] = x12r; |
| 4659 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 27] = x12i; |
| 4660 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 28] = x4r; |
| 4661 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 29] = x4i; |
| 4662 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 30] = x8r; |
| 4663 |
1
1. bitrv216neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 31] = x8i; |
| 4664 | } | |
| 4665 | ||
| 4666 | private void bitrv208(double[] a, int offa) { | |
| 4667 | double x1r, x1i, x3r, x3i, x4r, x4i, x6r, x6i; | |
| 4668 | ||
| 4669 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x1r = a[offa + 2]; |
| 4670 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x1i = a[offa + 3]; |
| 4671 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x3r = a[offa + 6]; |
| 4672 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x3i = a[offa + 7]; |
| 4673 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x4r = a[offa + 8]; |
| 4674 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x4i = a[offa + 9]; |
| 4675 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x6r = a[offa + 12]; |
| 4676 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
x6i = a[offa + 13]; |
| 4677 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x4r; |
| 4678 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x4i; |
| 4679 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 6] = x6r; |
| 4680 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 7] = x6i; |
| 4681 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 8] = x1r; |
| 4682 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 9] = x1i; |
| 4683 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 12] = x3r; |
| 4684 |
1
1. bitrv208 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 13] = x3i; |
| 4685 | } | |
| 4686 | ||
| 4687 | private void bitrv208neg(double[] a, int offa) { | |
| 4688 | double x1r, x1i, x2r, x2i, x3r, x3i, x4r, x4i, x5r, x5i, x6r, x6i, x7r, x7i; | |
| 4689 | ||
| 4690 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x1r = a[offa + 2]; |
| 4691 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x1i = a[offa + 3]; |
| 4692 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x2r = a[offa + 4]; |
| 4693 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x2i = a[offa + 5]; |
| 4694 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x3r = a[offa + 6]; |
| 4695 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x3i = a[offa + 7]; |
| 4696 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x4r = a[offa + 8]; |
| 4697 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x4i = a[offa + 9]; |
| 4698 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x5r = a[offa + 10]; |
| 4699 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x5i = a[offa + 11]; |
| 4700 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x6r = a[offa + 12]; |
| 4701 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x6i = a[offa + 13]; |
| 4702 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x7r = a[offa + 14]; |
| 4703 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
x7i = a[offa + 15]; |
| 4704 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x7r; |
| 4705 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x7i; |
| 4706 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 4] = x3r; |
| 4707 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 5] = x3i; |
| 4708 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 6] = x5r; |
| 4709 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 7] = x5i; |
| 4710 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 8] = x1r; |
| 4711 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 9] = x1i; |
| 4712 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 10] = x6r; |
| 4713 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 11] = x6i; |
| 4714 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 12] = x2r; |
| 4715 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 13] = x2i; |
| 4716 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 14] = x4r; |
| 4717 |
1
1. bitrv208neg : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 15] = x4i; |
| 4718 | } | |
| 4719 | ||
| 4720 | private void cftf1st(int n, double[] a, int offa, double[] w, int startw) { | |
| 4721 | int j0, j1, j2, j3, k, m, mh; | |
| 4722 | double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i; | |
| 4723 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i; | |
| 4724 | int idx0, idx1, idx2, idx3, idx4, idx5; | |
| 4725 |
1
1. cftf1st : Replaced Shift Right with Shift Left → NO_COVERAGE |
mh = n >> 3; |
| 4726 |
1
1. cftf1st : Replaced integer multiplication with division → NO_COVERAGE |
m = 2 * mh; |
| 4727 | j1 = m; | |
| 4728 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4729 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4730 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4731 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4732 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4733 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[idx2]; |
| 4734 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[idx2 + 1]; |
| 4735 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[idx2]; |
| 4736 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[idx2 + 1]; |
| 4737 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 4738 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 4739 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 4740 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 4741 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 4742 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x2i; |
| 4743 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 4744 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 4745 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = x1r - x3i; |
| 4746 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = x1i + x3r; |
| 4747 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = x1r + x3i; |
| 4748 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = x1i - x3r; |
| 4749 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 4750 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
csc1 = w[startw + 2]; |
| 4751 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
csc3 = w[startw + 3]; |
| 4752 | wd1r = 1; | |
| 4753 | wd1i = 0; | |
| 4754 | wd3r = 1; | |
| 4755 | wd3i = 0; | |
| 4756 | k = 0; | |
| 4757 |
3
1. cftf1st : changed conditional boundary → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : negated conditional → NO_COVERAGE |
for (int j = 2; j < mh - 2; j += 4) { |
| 4758 |
1
1. cftf1st : Changed increment from 4 to -4 → NO_COVERAGE |
k += 4; |
| 4759 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx4 = startw + k; |
| 4760 |
2
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk1r = csc1 * (wd1r + w[idx4]); |
| 4761 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk1i = csc1 * (wd1i + w[idx4 + 1]); |
| 4762 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk3r = csc3 * (wd3r + w[idx4 + 2]); |
| 4763 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk3i = csc3 * (wd3i + w[idx4 + 3]); |
| 4764 | wd1r = w[idx4]; | |
| 4765 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd1i = w[idx4 + 1]; |
| 4766 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd3r = w[idx4 + 2]; |
| 4767 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd3i = w[idx4 + 3]; |
| 4768 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j + m; |
| 4769 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4770 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4771 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4772 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4773 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4774 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx5 = offa + j; |
| 4775 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx5] + a[idx2]; |
| 4776 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx5 + 1] + a[idx2 + 1]; |
| 4777 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx5] - a[idx2]; |
| 4778 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx5 + 1] - a[idx2 + 1]; |
| 4779 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y0r = a[idx5 + 2] + a[idx2 + 2]; |
| 4780 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y0i = a[idx5 + 3] + a[idx2 + 3]; |
| 4781 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y1r = a[idx5 + 2] - a[idx2 + 2]; |
| 4782 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y1i = a[idx5 + 3] - a[idx2 + 3]; |
| 4783 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 4784 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 4785 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 4786 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 4787 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y2r = a[idx1 + 2] + a[idx3 + 2]; |
| 4788 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y2i = a[idx1 + 3] + a[idx3 + 3]; |
| 4789 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y3r = a[idx1 + 2] - a[idx3 + 2]; |
| 4790 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y3i = a[idx1 + 3] - a[idx3 + 3]; |
| 4791 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5] = x0r + x2r; |
| 4792 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5 + 1] = x0i + x2i; |
| 4793 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5 + 2] = y0r + y2r; |
| 4794 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5 + 3] = y0i + y2i; |
| 4795 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 4796 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 4797 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 2] = y0r - y2r; |
| 4798 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 3] = y0i - y2i; |
| 4799 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 4800 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 4801 |
3
1. cftf1st : Replaced double multiplication with division → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1r * x0r - wk1i * x0i; |
| 4802 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1r * x0i + wk1i * x0r; |
| 4803 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y1r - y3i; |
| 4804 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y1i + y3r; |
| 4805 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 2] = wd1r * x0r - wd1i * x0i; |
| 4806 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = wd1r * x0i + wd1i * x0r; |
| 4807 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 4808 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 4809 |
3
1. cftf1st : Replaced double multiplication with division → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3r * x0r + wk3i * x0i; |
| 4810 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3r * x0i - wk3i * x0r; |
| 4811 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y1r + y3i; |
| 4812 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y1i - y3r; |
| 4813 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 + 2] = wd3r * x0r + wd3i * x0i; |
| 4814 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 3] = wd3r * x0i - wd3i * x0r; |
| 4815 |
1
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE |
j0 = m - j; |
| 4816 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 4817 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4818 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4819 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 4820 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4821 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4822 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4823 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 4824 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2 + 1]; |
| 4825 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 4826 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2 + 1]; |
| 4827 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y0r = a[idx0 - 2] + a[idx2 - 2]; |
| 4828 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y0i = a[idx0 - 1] + a[idx2 - 1]; |
| 4829 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y1r = a[idx0 - 2] - a[idx2 - 2]; |
| 4830 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y1i = a[idx0 - 1] - a[idx2 - 1]; |
| 4831 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 4832 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 4833 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 4834 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 4835 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y2r = a[idx1 - 2] + a[idx3 - 2]; |
| 4836 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
y2i = a[idx1 - 1] + a[idx3 - 1]; |
| 4837 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y3r = a[idx1 - 2] - a[idx3 - 2]; |
| 4838 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
y3i = a[idx1 - 1] - a[idx3 - 1]; |
| 4839 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 4840 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = x0i + x2i; |
| 4841 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 2] = y0r + y2r; |
| 4842 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 1] = y0i + y2i; |
| 4843 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 4844 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 4845 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 2] = y0r - y2r; |
| 4846 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = y0i - y2i; |
| 4847 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 4848 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 4849 |
3
1. cftf1st : Replaced double multiplication with division → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1i * x0r - wk1r * x0i; |
| 4850 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1i * x0i + wk1r * x0r; |
| 4851 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y1r - y3i; |
| 4852 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y1i + y3r; |
| 4853 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 - 2] = wd1i * x0r - wd1r * x0i; |
| 4854 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 - 1] = wd1i * x0i + wd1r * x0r; |
| 4855 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 4856 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 4857 |
3
1. cftf1st : Replaced double multiplication with division → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3i * x0r + wk3r * x0i; |
| 4858 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3i * x0i - wk3r * x0r; |
| 4859 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y1r + y3i; |
| 4860 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y1i - y3r; |
| 4861 |
5
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double multiplication with division → NO_COVERAGE 5. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + j3 - 2] = wd3i * x0r + wd3r * x0i; |
| 4862 |
5
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double multiplication with division → NO_COVERAGE 5. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + j3 - 1] = wd3i * x0i - wd3r * x0r; |
| 4863 | } | |
| 4864 |
2
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk1r = csc1 * (wd1r + wn4r); |
| 4865 |
2
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk1i = csc1 * (wd1i + wn4r); |
| 4866 |
2
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk3r = csc3 * (wd3r - wn4r); |
| 4867 |
2
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
wk3i = csc3 * (wd3i - wn4r); |
| 4868 | j0 = mh; | |
| 4869 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 4870 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4871 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4872 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 4873 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4874 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4875 |
1
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4876 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0 - 2] + a[idx2 - 2]; |
| 4877 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 - 1] + a[idx2 - 1]; |
| 4878 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0 - 2] - a[idx2 - 2]; |
| 4879 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 - 1] - a[idx2 - 1]; |
| 4880 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1 - 2] + a[idx3 - 2]; |
| 4881 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 - 1] + a[idx3 - 1]; |
| 4882 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1 - 2] - a[idx3 - 2]; |
| 4883 |
3
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 - 1] - a[idx3 - 1]; |
| 4884 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 2] = x0r + x2r; |
| 4885 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 1] = x0i + x2i; |
| 4886 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 2] = x0r - x2r; |
| 4887 |
2
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 1] = x0i - x2i; |
| 4888 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 4889 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 4890 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 - 2] = wk1r * x0r - wk1i * x0i; |
| 4891 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 - 1] = wk1r * x0i + wk1i * x0r; |
| 4892 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 4893 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 4894 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 - 2] = wk3r * x0r + wk3i * x0i; |
| 4895 |
4
1. cftf1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 - 1] = wk3r * x0i - wk3i * x0r; |
| 4896 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 4897 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2 + 1]; |
| 4898 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 4899 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2 + 1]; |
| 4900 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 4901 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 4902 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 4903 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 4904 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 4905 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = x0i + x2i; |
| 4906 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 4907 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 4908 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 4909 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 4910 |
2
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx2] = wn4r * (x0r - x0i); |
| 4911 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx2 + 1] = wn4r * (x0i + x0r); |
| 4912 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 4913 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 4914 |
3
1. cftf1st : removed negation → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx3] = -wn4r * (x0r + x0i); |
| 4915 |
4
1. cftf1st : removed negation → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE 4. cftf1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx3 + 1] = -wn4r * (x0i - x0r); |
| 4916 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0 + 2] + a[idx2 + 2]; |
| 4917 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 3] + a[idx2 + 3]; |
| 4918 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0 + 2] - a[idx2 + 2]; |
| 4919 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 3] - a[idx2 + 3]; |
| 4920 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1 + 2] + a[idx3 + 2]; |
| 4921 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 3] + a[idx3 + 3]; |
| 4922 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1 + 2] - a[idx3 + 2]; |
| 4923 |
3
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 3] - a[idx3 + 3]; |
| 4924 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 2] = x0r + x2r; |
| 4925 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 3] = x0i + x2i; |
| 4926 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 2] = x0r - x2r; |
| 4927 |
2
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 3] = x0i - x2i; |
| 4928 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 4929 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 4930 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 2] = wk1i * x0r - wk1r * x0i; |
| 4931 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = wk1i * x0i + wk1r * x0r; |
| 4932 |
1
1. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 4933 |
1
1. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 4934 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 + 2] = wk3i * x0r + wk3r * x0i; |
| 4935 |
4
1. cftf1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf1st : Replaced double multiplication with division → NO_COVERAGE 3. cftf1st : Replaced double multiplication with division → NO_COVERAGE 4. cftf1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 3] = wk3i * x0i - wk3r * x0r; |
| 4936 | } | |
| 4937 | ||
| 4938 | private void cftb1st(int n, double[] a, int offa, double[] w, int startw) { | |
| 4939 | int j0, j1, j2, j3, k, m, mh; | |
| 4940 | double wn4r, csc1, csc3, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i; | |
| 4941 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i; | |
| 4942 | int idx0, idx1, idx2, idx3, idx4, idx5; | |
| 4943 |
1
1. cftb1st : Replaced Shift Right with Shift Left → NO_COVERAGE |
mh = n >> 3; |
| 4944 |
1
1. cftb1st : Replaced integer multiplication with division → NO_COVERAGE |
m = 2 * mh; |
| 4945 | j1 = m; | |
| 4946 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4947 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4948 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4949 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4950 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4951 | ||
| 4952 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[idx2]; |
| 4953 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[offa + 1] - a[idx2 + 1]; |
| 4954 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[idx2]; |
| 4955 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[offa + 1] + a[idx2 + 1]; |
| 4956 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 4957 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 4958 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 4959 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 4960 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 4961 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 1] = x0i - x2i; |
| 4962 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 4963 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = x0i + x2i; |
| 4964 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2] = x1r + x3i; |
| 4965 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = x1i + x3r; |
| 4966 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3] = x1r - x3i; |
| 4967 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = x1i - x3r; |
| 4968 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 4969 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
csc1 = w[startw + 2]; |
| 4970 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
csc3 = w[startw + 3]; |
| 4971 | wd1r = 1; | |
| 4972 | wd1i = 0; | |
| 4973 | wd3r = 1; | |
| 4974 | wd3i = 0; | |
| 4975 | k = 0; | |
| 4976 |
3
1. cftb1st : changed conditional boundary → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : negated conditional → NO_COVERAGE |
for (int j = 2; j < mh - 2; j += 4) { |
| 4977 |
1
1. cftb1st : Changed increment from 4 to -4 → NO_COVERAGE |
k += 4; |
| 4978 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx4 = startw + k; |
| 4979 |
2
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk1r = csc1 * (wd1r + w[idx4]); |
| 4980 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk1i = csc1 * (wd1i + w[idx4 + 1]); |
| 4981 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk3r = csc3 * (wd3r + w[idx4 + 2]); |
| 4982 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk3i = csc3 * (wd3i + w[idx4 + 3]); |
| 4983 | wd1r = w[idx4]; | |
| 4984 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd1i = w[idx4 + 1]; |
| 4985 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd3r = w[idx4 + 2]; |
| 4986 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
wd3i = w[idx4 + 3]; |
| 4987 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j + m; |
| 4988 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 4989 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 4990 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 4991 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 4992 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 4993 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx5 = offa + j; |
| 4994 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx5] + a[idx2]; |
| 4995 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[idx5 + 1] - a[idx2 + 1]; |
| 4996 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx5] - a[offa + j2]; |
| 4997 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[idx5 + 1] + a[idx2 + 1]; |
| 4998 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y0r = a[idx5 + 2] + a[idx2 + 2]; |
| 4999 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y0i = -a[idx5 + 3] - a[idx2 + 3]; |
| 5000 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y1r = a[idx5 + 2] - a[idx2 + 2]; |
| 5001 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y1i = -a[idx5 + 3] + a[idx2 + 3]; |
| 5002 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5003 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5004 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5005 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5006 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y2r = a[idx1 + 2] + a[idx3 + 2]; |
| 5007 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y2i = a[idx1 + 3] + a[idx3 + 3]; |
| 5008 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y3r = a[idx1 + 2] - a[idx3 + 2]; |
| 5009 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y3i = a[idx1 + 3] - a[idx3 + 3]; |
| 5010 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5] = x0r + x2r; |
| 5011 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx5 + 1] = x0i - x2i; |
| 5012 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5 + 2] = y0r + y2r; |
| 5013 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx5 + 3] = y0i - y2i; |
| 5014 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5015 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = x0i + x2i; |
| 5016 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 2] = y0r - y2r; |
| 5017 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 3] = y0i + y2i; |
| 5018 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5019 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5020 |
3
1. cftb1st : Replaced double multiplication with division → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1r * x0r - wk1i * x0i; |
| 5021 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1r * x0i + wk1i * x0r; |
| 5022 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y1r + y3i; |
| 5023 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y1i + y3r; |
| 5024 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 2] = wd1r * x0r - wd1i * x0i; |
| 5025 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = wd1r * x0i + wd1i * x0r; |
| 5026 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5027 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5028 |
3
1. cftb1st : Replaced double multiplication with division → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3r * x0r + wk3i * x0i; |
| 5029 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3r * x0i - wk3i * x0r; |
| 5030 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y1r - y3i; |
| 5031 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y1i - y3r; |
| 5032 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 + 2] = wd3r * x0r + wd3i * x0i; |
| 5033 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 3] = wd3r * x0i - wd3i * x0r; |
| 5034 |
1
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE |
j0 = m - j; |
| 5035 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5036 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5037 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5038 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5039 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5040 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5041 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5042 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 5043 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[idx0 + 1] - a[idx2 + 1]; |
| 5044 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 5045 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[idx0 + 1] + a[idx2 + 1]; |
| 5046 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y0r = a[idx0 - 2] + a[idx2 - 2]; |
| 5047 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y0i = -a[idx0 - 1] - a[idx2 - 1]; |
| 5048 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y1r = a[idx0 - 2] - a[idx2 - 2]; |
| 5049 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y1i = -a[idx0 - 1] + a[idx2 - 1]; |
| 5050 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5051 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5052 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5053 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5054 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y2r = a[idx1 - 2] + a[idx3 - 2]; |
| 5055 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
y2i = a[idx1 - 1] + a[idx3 - 1]; |
| 5056 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y3r = a[idx1 - 2] - a[idx3 - 2]; |
| 5057 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
y3i = a[idx1 - 1] - a[idx3 - 1]; |
| 5058 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 5059 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx0 + 1] = x0i - x2i; |
| 5060 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 2] = y0r + y2r; |
| 5061 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx0 - 1] = y0i - y2i; |
| 5062 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5063 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = x0i + x2i; |
| 5064 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 2] = y0r - y2r; |
| 5065 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 - 1] = y0i + y2i; |
| 5066 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5067 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5068 |
3
1. cftb1st : Replaced double multiplication with division → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1i * x0r - wk1r * x0i; |
| 5069 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1i * x0i + wk1r * x0r; |
| 5070 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y1r + y3i; |
| 5071 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y1i + y3r; |
| 5072 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 - 2] = wd1i * x0r - wd1r * x0i; |
| 5073 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 - 1] = wd1i * x0i + wd1r * x0r; |
| 5074 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5075 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5076 |
3
1. cftb1st : Replaced double multiplication with division → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3i * x0r + wk3r * x0i; |
| 5077 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3i * x0i - wk3r * x0r; |
| 5078 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y1r - y3i; |
| 5079 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y1i - y3r; |
| 5080 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 - 2] = wd3i * x0r + wd3r * x0i; |
| 5081 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 - 1] = wd3i * x0i - wd3r * x0r; |
| 5082 | } | |
| 5083 |
2
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk1r = csc1 * (wd1r + wn4r); |
| 5084 |
2
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk1i = csc1 * (wd1i + wn4r); |
| 5085 |
2
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk3r = csc3 * (wd3r - wn4r); |
| 5086 |
2
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
wk3i = csc3 * (wd3i - wn4r); |
| 5087 | j0 = mh; | |
| 5088 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5089 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5090 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5091 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5092 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5093 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5094 |
1
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5095 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0 - 2] + a[idx2 - 2]; |
| 5096 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[idx0 - 1] - a[idx2 - 1]; |
| 5097 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0 - 2] - a[idx2 - 2]; |
| 5098 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[idx0 - 1] + a[idx2 - 1]; |
| 5099 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1 - 2] + a[idx3 - 2]; |
| 5100 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 - 1] + a[idx3 - 1]; |
| 5101 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1 - 2] - a[idx3 - 2]; |
| 5102 |
3
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 - 1] - a[idx3 - 1]; |
| 5103 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 - 2] = x0r + x2r; |
| 5104 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx0 - 1] = x0i - x2i; |
| 5105 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 - 2] = x0r - x2r; |
| 5106 |
2
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 - 1] = x0i + x2i; |
| 5107 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5108 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5109 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 - 2] = wk1r * x0r - wk1i * x0i; |
| 5110 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 - 1] = wk1r * x0i + wk1i * x0r; |
| 5111 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5112 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5113 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 - 2] = wk3r * x0r + wk3i * x0i; |
| 5114 |
4
1. cftb1st : Replaced integer subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 - 1] = wk3r * x0i - wk3i * x0r; |
| 5115 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 5116 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[idx0 + 1] - a[idx2 + 1]; |
| 5117 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 5118 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[idx0 + 1] + a[idx2 + 1]; |
| 5119 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5120 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5121 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5122 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5123 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 5124 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx0 + 1] = x0i - x2i; |
| 5125 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5126 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 1] = x0i + x2i; |
| 5127 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5128 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5129 |
2
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx2] = wn4r * (x0r - x0i); |
| 5130 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx2 + 1] = wn4r * (x0i + x0r); |
| 5131 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5132 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5133 |
3
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx3] = -wn4r * (x0r + x0i); |
| 5134 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE 4. cftb1st : Replaced double multiplication with division → NO_COVERAGE |
a[idx3 + 1] = -wn4r * (x0i - x0r); |
| 5135 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0 + 2] + a[idx2 + 2]; |
| 5136 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = -a[idx0 + 3] - a[idx2 + 3]; |
| 5137 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0 + 2] - a[idx2 + 2]; |
| 5138 |
4
1. cftb1st : removed negation → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x1i = -a[idx0 + 3] + a[idx2 + 3]; |
| 5139 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1 + 2] + a[idx3 + 2]; |
| 5140 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 3] + a[idx3 + 3]; |
| 5141 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1 + 2] - a[idx3 + 2]; |
| 5142 |
3
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 3] - a[idx3 + 3]; |
| 5143 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 2] = x0r + x2r; |
| 5144 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx0 + 3] = x0i - x2i; |
| 5145 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 2] = x0r - x2r; |
| 5146 |
2
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx1 + 3] = x0i + x2i; |
| 5147 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5148 |
1
1. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5149 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 2] = wk1i * x0r - wk1r * x0i; |
| 5150 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 3] = wk1i * x0i + wk1r * x0r; |
| 5151 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5152 |
1
1. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5153 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 + 2] = wk3i * x0r + wk3r * x0i; |
| 5154 |
4
1. cftb1st : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb1st : Replaced double multiplication with division → NO_COVERAGE 3. cftb1st : Replaced double multiplication with division → NO_COVERAGE 4. cftb1st : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 3] = wk3i * x0i - wk3r * x0r; |
| 5155 | } | |
| 5156 | ||
| 5157 | private void cftrec4(int n, double[] a, int offa, int nw, double[] w) { | |
| 5158 | int isplt, j, k, m; | |
| 5159 | ||
| 5160 | m = n; | |
| 5161 |
1
1. cftrec4 : Replaced integer addition with subtraction → NO_COVERAGE |
int idx1 = offa + n; |
| 5162 |
2
1. cftrec4 : changed conditional boundary → NO_COVERAGE 2. cftrec4 : negated conditional → NO_COVERAGE |
while (m > 512) { |
| 5163 |
1
1. cftrec4 : Replaced Shift Right with Shift Left → NO_COVERAGE |
m >>= 2; |
| 5164 |
4
1. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE 2. cftrec4 : Replaced Shift Right with Shift Left → NO_COVERAGE 3. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE 4. cftrec4 : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(m, a, idx1 - m, w, nw - (m >> 1)); |
| 5165 | } | |
| 5166 |
2
1. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE 2. cftrec4 : removed call to mikera/matrixx/algo/FFT::cftleaf → NO_COVERAGE |
cftleaf(m, 1, a, idx1 - m, nw, w); |
| 5167 | k = 0; | |
| 5168 |
1
1. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE |
int idx2 = offa - m; |
| 5169 |
4
1. cftrec4 : changed conditional boundary → NO_COVERAGE 2. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftrec4 : Replaced integer subtraction with addition → NO_COVERAGE 4. cftrec4 : negated conditional → NO_COVERAGE |
for (j = n - m; j > 0; j -= m) { |
| 5170 |
1
1. cftrec4 : Changed increment from 1 to -1 → NO_COVERAGE |
k++; |
| 5171 | isplt = cfttree(m, j, k, a, offa, nw, w); | |
| 5172 |
2
1. cftrec4 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftrec4 : removed call to mikera/matrixx/algo/FFT::cftleaf → NO_COVERAGE |
cftleaf(m, isplt, a, idx2 + j, nw, w); |
| 5173 | } | |
| 5174 | } | |
| 5175 | ||
| 5176 | private int cfttree(int n, int j, int k, double[] a, int offa, int nw, double[] w) { | |
| 5177 | int i, isplt, m; | |
| 5178 |
1
1. cfttree : Replaced integer subtraction with addition → NO_COVERAGE |
int idx1 = offa - n; |
| 5179 |
2
1. cfttree : Replaced bitwise AND with OR → NO_COVERAGE 2. cfttree : negated conditional → NO_COVERAGE |
if ((k & 3) != 0) { |
| 5180 |
1
1. cfttree : Replaced bitwise AND with OR → NO_COVERAGE |
isplt = k & 1; |
| 5181 |
1
1. cfttree : negated conditional → NO_COVERAGE |
if (isplt != 0) { |
| 5182 |
4
1. cfttree : Replaced integer addition with subtraction → NO_COVERAGE 2. cfttree : Replaced Shift Right with Shift Left → NO_COVERAGE 3. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 4. cfttree : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(n, a, idx1 + j, w, nw - (n >> 1)); |
| 5183 | } else { | |
| 5184 |
3
1. cfttree : Replaced integer addition with subtraction → NO_COVERAGE 2. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 3. cfttree : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(n, a, idx1 + j, w, nw - n); |
| 5185 | } | |
| 5186 | } else { | |
| 5187 | m = n; | |
| 5188 |
3
1. cfttree : Replaced bitwise AND with OR → NO_COVERAGE 2. cfttree : Replaced Shift Right with Shift Left → NO_COVERAGE 3. cfttree : negated conditional → NO_COVERAGE |
for (i = k; (i & 3) == 0; i >>= 2) { |
| 5189 |
1
1. cfttree : Replaced Shift Left with Shift Right → NO_COVERAGE |
m <<= 2; |
| 5190 | } | |
| 5191 |
1
1. cfttree : Replaced bitwise AND with OR → NO_COVERAGE |
isplt = i & 1; |
| 5192 |
1
1. cfttree : Replaced integer addition with subtraction → NO_COVERAGE |
int idx2 = offa + j; |
| 5193 |
1
1. cfttree : negated conditional → NO_COVERAGE |
if (isplt != 0) { |
| 5194 |
2
1. cfttree : changed conditional boundary → NO_COVERAGE 2. cfttree : negated conditional → NO_COVERAGE |
while (m > 128) { |
| 5195 |
4
1. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 2. cfttree : Replaced Shift Right with Shift Left → NO_COVERAGE 3. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 4. cfttree : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(m, a, idx2 - m, w, nw - (m >> 1)); |
| 5196 |
1
1. cfttree : Replaced Shift Right with Shift Left → NO_COVERAGE |
m >>= 2; |
| 5197 | } | |
| 5198 | } else { | |
| 5199 |
2
1. cfttree : changed conditional boundary → NO_COVERAGE 2. cfttree : negated conditional → NO_COVERAGE |
while (m > 128) { |
| 5200 |
3
1. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 2. cfttree : Replaced integer subtraction with addition → NO_COVERAGE 3. cfttree : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(m, a, idx2 - m, w, nw - m); |
| 5201 |
1
1. cfttree : Replaced Shift Right with Shift Left → NO_COVERAGE |
m >>= 2; |
| 5202 | } | |
| 5203 | } | |
| 5204 | } | |
| 5205 |
1
1. cfttree : replaced int return with 0 for mikera/matrixx/algo/FFT::cfttree → NO_COVERAGE |
return isplt; |
| 5206 | } | |
| 5207 | ||
| 5208 | private void cftleaf(int n, int isplt, double[] a, int offa, int nw, double[] w) { | |
| 5209 |
1
1. cftleaf : negated conditional → NO_COVERAGE |
if (n == 512) { |
| 5210 |
2
1. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 2. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(128, a, offa, w, nw - 64); |
| 5211 |
2
1. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 2. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa, w, nw - 8); |
| 5212 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 32, w, nw - 32); |
| 5213 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 64, w, nw - 8); |
| 5214 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 96, w, nw - 8); |
| 5215 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(128, a, offa + 128, w, nw - 128); |
| 5216 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 128, w, nw - 8); |
| 5217 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 160, w, nw - 32); |
| 5218 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 192, w, nw - 8); |
| 5219 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 224, w, nw - 32); |
| 5220 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(128, a, offa + 256, w, nw - 64); |
| 5221 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 256, w, nw - 8); |
| 5222 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 288, w, nw - 32); |
| 5223 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 320, w, nw - 8); |
| 5224 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 352, w, nw - 8); |
| 5225 |
1
1. cftleaf : negated conditional → NO_COVERAGE |
if (isplt != 0) { |
| 5226 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(128, a, offa + 384, w, nw - 64); |
| 5227 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 480, w, nw - 8); |
| 5228 | } else { | |
| 5229 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(128, a, offa + 384, w, nw - 128); |
| 5230 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 480, w, nw - 32); |
| 5231 | } | |
| 5232 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 384, w, nw - 8); |
| 5233 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 416, w, nw - 32); |
| 5234 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 448, w, nw - 8); |
| 5235 | } else { | |
| 5236 |
2
1. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 2. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(64, a, offa, w, nw - 32); |
| 5237 |
2
1. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 2. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa, w, nw - 8); |
| 5238 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 16, w, nw - 8); |
| 5239 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 32, w, nw - 8); |
| 5240 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 48, w, nw - 8); |
| 5241 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(64, a, offa + 64, w, nw - 64); |
| 5242 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 64, w, nw - 8); |
| 5243 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 80, w, nw - 8); |
| 5244 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 96, w, nw - 8); |
| 5245 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 112, w, nw - 8); |
| 5246 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(64, a, offa + 128, w, nw - 32); |
| 5247 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 128, w, nw - 8); |
| 5248 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 144, w, nw - 8); |
| 5249 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 160, w, nw - 8); |
| 5250 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 176, w, nw - 8); |
| 5251 |
1
1. cftleaf : negated conditional → NO_COVERAGE |
if (isplt != 0) { |
| 5252 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl1 → NO_COVERAGE |
cftmdl1(64, a, offa + 192, w, nw - 32); |
| 5253 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 240, w, nw - 8); |
| 5254 | } else { | |
| 5255 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftmdl2 → NO_COVERAGE |
cftmdl2(64, a, offa + 192, w, nw - 64); |
| 5256 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 240, w, nw - 8); |
| 5257 | } | |
| 5258 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 192, w, nw - 8); |
| 5259 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 208, w, nw - 8); |
| 5260 |
3
1. cftleaf : Replaced integer addition with subtraction → NO_COVERAGE 2. cftleaf : Replaced integer subtraction with addition → NO_COVERAGE 3. cftleaf : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 224, w, nw - 8); |
| 5261 | } | |
| 5262 | } | |
| 5263 | ||
| 5264 | private void cftmdl1(int n, double[] a, int offa, double[] w, int startw) { | |
| 5265 | int j0, j1, j2, j3, k, m, mh; | |
| 5266 | double wn4r, wk1r, wk1i, wk3r, wk3i; | |
| 5267 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i; | |
| 5268 | int idx0, idx1, idx2, idx3, idx4, idx5; | |
| 5269 | ||
| 5270 |
1
1. cftmdl1 : Replaced Shift Right with Shift Left → NO_COVERAGE |
mh = n >> 3; |
| 5271 |
1
1. cftmdl1 : Replaced integer multiplication with division → NO_COVERAGE |
m = 2 * mh; |
| 5272 | j1 = m; | |
| 5273 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5274 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5275 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5276 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5277 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5278 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[idx2]; |
| 5279 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[idx2 + 1]; |
| 5280 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[idx2]; |
| 5281 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[idx2 + 1]; |
| 5282 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5283 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5284 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5285 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5286 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 5287 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x2i; |
| 5288 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5289 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 5290 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = x1r - x3i; |
| 5291 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = x1i + x3r; |
| 5292 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = x1r + x3i; |
| 5293 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = x1i - x3r; |
| 5294 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5295 | k = 0; | |
| 5296 |
2
1. cftmdl1 : changed conditional boundary → NO_COVERAGE 2. cftmdl1 : negated conditional → NO_COVERAGE |
for (int j = 2; j < mh; j += 2) { |
| 5297 |
1
1. cftmdl1 : Changed increment from 4 to -4 → NO_COVERAGE |
k += 4; |
| 5298 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx4 = startw + k; |
| 5299 | wk1r = w[idx4]; | |
| 5300 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[idx4 + 1]; |
| 5301 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3r = w[idx4 + 2]; |
| 5302 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3i = w[idx4 + 3]; |
| 5303 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j + m; |
| 5304 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5305 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5306 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5307 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5308 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5309 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx5 = offa + j; |
| 5310 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx5] + a[idx2]; |
| 5311 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx5 + 1] + a[idx2 + 1]; |
| 5312 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx5] - a[idx2]; |
| 5313 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx5 + 1] - a[idx2 + 1]; |
| 5314 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5315 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5316 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5317 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5318 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5] = x0r + x2r; |
| 5319 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx5 + 1] = x0i + x2i; |
| 5320 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5321 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 5322 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5323 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5324 |
3
1. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1r * x0r - wk1i * x0i; |
| 5325 |
4
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 4. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1r * x0i + wk1i * x0r; |
| 5326 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5327 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5328 |
3
1. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3r * x0r + wk3i * x0i; |
| 5329 |
4
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 4. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3r * x0i - wk3i * x0r; |
| 5330 |
1
1. cftmdl1 : Replaced integer subtraction with addition → NO_COVERAGE |
j0 = m - j; |
| 5331 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5332 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5333 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5334 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5335 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5336 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5337 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5338 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 5339 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2 + 1]; |
| 5340 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 5341 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2 + 1]; |
| 5342 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5343 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5344 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5345 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5346 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 5347 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = x0i + x2i; |
| 5348 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5349 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 5350 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5351 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5352 |
3
1. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = wk1i * x0r - wk1r * x0i; |
| 5353 |
4
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 4. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = wk1i * x0i + wk1r * x0r; |
| 5354 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5355 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5356 |
3
1. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = wk3i * x0r + wk3r * x0i; |
| 5357 |
4
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE 4. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = wk3i * x0i - wk3r * x0r; |
| 5358 | } | |
| 5359 | j0 = mh; | |
| 5360 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5361 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5362 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5363 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5364 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5365 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5366 |
1
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5367 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[idx0] + a[idx2]; |
| 5368 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2 + 1]; |
| 5369 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[idx0] - a[idx2]; |
| 5370 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2 + 1]; |
| 5371 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[idx1] + a[idx3]; |
| 5372 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3 + 1]; |
| 5373 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[idx1] - a[idx3]; |
| 5374 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3 + 1]; |
| 5375 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = x0r + x2r; |
| 5376 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = x0i + x2i; |
| 5377 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - x2r; |
| 5378 |
2
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - x2i; |
| 5379 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5380 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5381 |
2
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE 2. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE |
a[idx2] = wn4r * (x0r - x0i); |
| 5382 |
3
1. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE |
a[idx2 + 1] = wn4r * (x0i + x0r); |
| 5383 |
1
1. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5384 |
1
1. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5385 |
3
1. cftmdl1 : removed negation → NO_COVERAGE 2. cftmdl1 : Replaced double addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE |
a[idx3] = -wn4r * (x0r + x0i); |
| 5386 |
4
1. cftmdl1 : removed negation → NO_COVERAGE 2. cftmdl1 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftmdl1 : Replaced double subtraction with addition → NO_COVERAGE 4. cftmdl1 : Replaced double multiplication with division → NO_COVERAGE |
a[idx3 + 1] = -wn4r * (x0i - x0r); |
| 5387 | } | |
| 5388 | ||
| 5389 | private void cftmdl2(int n, double[] a, int offa, double[] w, int startw) { | |
| 5390 | int j0, j1, j2, j3, k, kr, m, mh; | |
| 5391 | double wn4r, wk1r, wk1i, wk3r, wk3i, wd1r, wd1i, wd3r, wd3i; | |
| 5392 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y2r, y2i; | |
| 5393 | int idx0, idx1, idx2, idx3, idx4, idx5, idx6; | |
| 5394 | ||
| 5395 |
1
1. cftmdl2 : Replaced Shift Right with Shift Left → NO_COVERAGE |
mh = n >> 3; |
| 5396 |
1
1. cftmdl2 : Replaced integer multiplication with division → NO_COVERAGE |
m = 2 * mh; |
| 5397 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5398 | j1 = m; | |
| 5399 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5400 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5401 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5402 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5403 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5404 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa] - a[idx2 + 1]; |
| 5405 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[idx2]; |
| 5406 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = a[offa] + a[idx2 + 1]; |
| 5407 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[idx2]; |
| 5408 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = a[idx1] - a[idx3 + 1]; |
| 5409 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3]; |
| 5410 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x3r = a[idx1] + a[idx3 + 1]; |
| 5411 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3]; |
| 5412 |
2
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE |
y0r = wn4r * (x2r - x2i); |
| 5413 |
2
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE |
y0i = wn4r * (x2i + x2r); |
| 5414 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + y0r; |
| 5415 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + y0i; |
| 5416 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = x0r - y0r; |
| 5417 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = x0i - y0i; |
| 5418 |
2
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE |
y0r = wn4r * (x3r - x3i); |
| 5419 |
2
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE |
y0i = wn4r * (x3i + x3r); |
| 5420 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = x1r - y0i; |
| 5421 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = x1i + y0r; |
| 5422 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = x1r + y0i; |
| 5423 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = x1i - y0r; |
| 5424 | k = 0; | |
| 5425 |
1
1. cftmdl2 : Replaced integer multiplication with division → NO_COVERAGE |
kr = 2 * m; |
| 5426 |
2
1. cftmdl2 : changed conditional boundary → NO_COVERAGE 2. cftmdl2 : negated conditional → NO_COVERAGE |
for (int j = 2; j < mh; j += 2) { |
| 5427 |
1
1. cftmdl2 : Changed increment from 4 to -4 → NO_COVERAGE |
k += 4; |
| 5428 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx4 = startw + k; |
| 5429 | wk1r = w[idx4]; | |
| 5430 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[idx4 + 1]; |
| 5431 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3r = w[idx4 + 2]; |
| 5432 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3i = w[idx4 + 3]; |
| 5433 |
1
1. cftmdl2 : Changed increment from -4 to 4 → NO_COVERAGE |
kr -= 4; |
| 5434 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx5 = startw + kr; |
| 5435 | wd1i = w[idx5]; | |
| 5436 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wd1r = w[idx5 + 1]; |
| 5437 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wd3i = w[idx5 + 2]; |
| 5438 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wd3r = w[idx5 + 3]; |
| 5439 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j + m; |
| 5440 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5441 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5442 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5443 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5444 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5445 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx6 = offa + j; |
| 5446 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[idx6] - a[idx2 + 1]; |
| 5447 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx6 + 1] + a[idx2]; |
| 5448 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = a[idx6] + a[idx2 + 1]; |
| 5449 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx6 + 1] - a[idx2]; |
| 5450 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = a[idx1] - a[idx3 + 1]; |
| 5451 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3]; |
| 5452 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x3r = a[idx1] + a[idx3 + 1]; |
| 5453 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3]; |
| 5454 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0r = wk1r * x0r - wk1i * x0i; |
| 5455 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = wk1r * x0i + wk1i * x0r; |
| 5456 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2r = wd1r * x2r - wd1i * x2i; |
| 5457 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = wd1r * x2i + wd1i * x2r; |
| 5458 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx6] = y0r + y2r; |
| 5459 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx6 + 1] = y0i + y2i; |
| 5460 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = y0r - y2r; |
| 5461 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = y0i - y2i; |
| 5462 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0r = wk3r * x1r + wk3i * x1i; |
| 5463 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0i = wk3r * x1i - wk3i * x1r; |
| 5464 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2r = wd3r * x3r + wd3i * x3i; |
| 5465 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2i = wd3r * x3i - wd3i * x3r; |
| 5466 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2] = y0r + y2r; |
| 5467 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = y0i + y2i; |
| 5468 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3] = y0r - y2r; |
| 5469 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = y0i - y2i; |
| 5470 |
1
1. cftmdl2 : Replaced integer subtraction with addition → NO_COVERAGE |
j0 = m - j; |
| 5471 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5472 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5473 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5474 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5475 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5476 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5477 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5478 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[idx0] - a[idx2 + 1]; |
| 5479 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2]; |
| 5480 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = a[idx0] + a[idx2 + 1]; |
| 5481 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2]; |
| 5482 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = a[idx1] - a[idx3 + 1]; |
| 5483 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3]; |
| 5484 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x3r = a[idx1] + a[idx3 + 1]; |
| 5485 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3]; |
| 5486 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0r = wd1i * x0r - wd1r * x0i; |
| 5487 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = wd1i * x0i + wd1r * x0r; |
| 5488 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2r = wk1i * x2r - wk1r * x2i; |
| 5489 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = wk1i * x2i + wk1r * x2r; |
| 5490 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = y0r + y2r; |
| 5491 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = y0i + y2i; |
| 5492 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = y0r - y2r; |
| 5493 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = y0i - y2i; |
| 5494 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0r = wd3i * x1r + wd3r * x1i; |
| 5495 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0i = wd3i * x1i - wd3r * x1r; |
| 5496 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2r = wk3i * x3r + wk3r * x3i; |
| 5497 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2i = wk3i * x3i - wk3r * x3r; |
| 5498 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2] = y0r + y2r; |
| 5499 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2 + 1] = y0i + y2i; |
| 5500 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3] = y0r - y2r; |
| 5501 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx3 + 1] = y0i - y2i; |
| 5502 | } | |
| 5503 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[startw + m]; |
| 5504 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[startw + m + 1]; |
| 5505 | j0 = mh; | |
| 5506 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j1 = j0 + m; |
| 5507 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j2 = j1 + m; |
| 5508 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
j3 = j2 + m; |
| 5509 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx0 = offa + j0; |
| 5510 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j1; |
| 5511 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + j2; |
| 5512 |
1
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE |
idx3 = offa + j3; |
| 5513 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[idx0] - a[idx2 + 1]; |
| 5514 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[idx0 + 1] + a[idx2]; |
| 5515 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = a[idx0] + a[idx2 + 1]; |
| 5516 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[idx0 + 1] - a[idx2]; |
| 5517 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = a[idx1] - a[idx3 + 1]; |
| 5518 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[idx1 + 1] + a[idx3]; |
| 5519 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
x3r = a[idx1] + a[idx3 + 1]; |
| 5520 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[idx1 + 1] - a[idx3]; |
| 5521 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0r = wk1r * x0r - wk1i * x0i; |
| 5522 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = wk1r * x0i + wk1i * x0r; |
| 5523 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2r = wk1i * x2r - wk1r * x2i; |
| 5524 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = wk1i * x2i + wk1r * x2r; |
| 5525 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0] = y0r + y2r; |
| 5526 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx0 + 1] = y0i + y2i; |
| 5527 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] = y0r - y2r; |
| 5528 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = y0i - y2i; |
| 5529 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y0r = wk1i * x1r - wk1r * x1i; |
| 5530 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = wk1i * x1i + wk1r * x1r; |
| 5531 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
y2r = wk1r * x3r - wk1i * x3i; |
| 5532 |
3
1. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 2. cftmdl2 : Replaced double multiplication with division → NO_COVERAGE 3. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = wk1r * x3i + wk1i * x3r; |
| 5533 |
1
1. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2] = y0r - y2r; |
| 5534 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 1] = y0i - y2i; |
| 5535 |
1
1. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3] = y0r + y2r; |
| 5536 |
2
1. cftmdl2 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftmdl2 : Replaced double addition with subtraction → NO_COVERAGE |
a[idx3 + 1] = y0i + y2i; |
| 5537 | } | |
| 5538 | ||
| 5539 | private void cftfx41(int n, double[] a, int offa, int nw, double[] w) { | |
| 5540 |
1
1. cftfx41 : negated conditional → NO_COVERAGE |
if (n == 128) { |
| 5541 |
2
1. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 2. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa, w, nw - 8); |
| 5542 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf162 → NO_COVERAGE |
cftf162(a, offa + 32, w, nw - 32); |
| 5543 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 64, w, nw - 8); |
| 5544 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf161 → NO_COVERAGE |
cftf161(a, offa + 96, w, nw - 8); |
| 5545 | } else { | |
| 5546 |
2
1. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 2. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa, w, nw - 8); |
| 5547 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf082 → NO_COVERAGE |
cftf082(a, offa + 16, w, nw - 8); |
| 5548 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 32, w, nw - 8); |
| 5549 |
3
1. cftfx41 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftfx41 : Replaced integer subtraction with addition → NO_COVERAGE 3. cftfx41 : removed call to mikera/matrixx/algo/FFT::cftf081 → NO_COVERAGE |
cftf081(a, offa + 48, w, nw - 8); |
| 5550 | } | |
| 5551 | } | |
| 5552 | ||
| 5553 | private void cftf161(double[] a, int offa, double[] w, int startw) { | |
| 5554 | double wn4r, wk1r, wk1i, x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i; | |
| 5555 | ||
| 5556 |
1
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5557 |
1
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[startw + 2]; |
| 5558 |
1
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[startw + 3]; |
| 5559 | ||
| 5560 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[offa + 16]; |
| 5561 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[offa + 17]; |
| 5562 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[offa + 16]; |
| 5563 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[offa + 17]; |
| 5564 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 8] + a[offa + 24]; |
| 5565 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 9] + a[offa + 25]; |
| 5566 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 8] - a[offa + 24]; |
| 5567 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 9] - a[offa + 25]; |
| 5568 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y0r = x0r + x2r; |
| 5569 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = x0i + x2i; |
| 5570 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y4r = x0r - x2r; |
| 5571 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y4i = x0i - x2i; |
| 5572 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y8r = x1r - x3i; |
| 5573 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y8i = x1i + x3r; |
| 5574 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y12r = x1r + x3i; |
| 5575 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y12i = x1i - x3r; |
| 5576 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 2] + a[offa + 18]; |
| 5577 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 3] + a[offa + 19]; |
| 5578 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa + 2] - a[offa + 18]; |
| 5579 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 3] - a[offa + 19]; |
| 5580 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 10] + a[offa + 26]; |
| 5581 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 11] + a[offa + 27]; |
| 5582 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 10] - a[offa + 26]; |
| 5583 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 11] - a[offa + 27]; |
| 5584 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y1r = x0r + x2r; |
| 5585 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y1i = x0i + x2i; |
| 5586 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y5r = x0r - x2r; |
| 5587 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y5i = x0i - x2i; |
| 5588 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5589 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5590 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y9r = wk1r * x0r - wk1i * x0i; |
| 5591 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y9i = wk1r * x0i + wk1i * x0r; |
| 5592 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5593 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5594 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y13r = wk1i * x0r - wk1r * x0i; |
| 5595 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y13i = wk1i * x0i + wk1r * x0r; |
| 5596 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 4] + a[offa + 20]; |
| 5597 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 5] + a[offa + 21]; |
| 5598 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa + 4] - a[offa + 20]; |
| 5599 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 5] - a[offa + 21]; |
| 5600 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 12] + a[offa + 28]; |
| 5601 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 13] + a[offa + 29]; |
| 5602 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 12] - a[offa + 28]; |
| 5603 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 13] - a[offa + 29]; |
| 5604 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y2r = x0r + x2r; |
| 5605 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = x0i + x2i; |
| 5606 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y6r = x0r - x2r; |
| 5607 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y6i = x0i - x2i; |
| 5608 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5609 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5610 |
2
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
y10r = wn4r * (x0r - x0i); |
| 5611 |
2
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
y10i = wn4r * (x0i + x0r); |
| 5612 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5613 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5614 |
2
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
y14r = wn4r * (x0r + x0i); |
| 5615 |
2
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
y14i = wn4r * (x0i - x0r); |
| 5616 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 6] + a[offa + 22]; |
| 5617 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 7] + a[offa + 23]; |
| 5618 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa + 6] - a[offa + 22]; |
| 5619 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 7] - a[offa + 23]; |
| 5620 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 14] + a[offa + 30]; |
| 5621 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 15] + a[offa + 31]; |
| 5622 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 14] - a[offa + 30]; |
| 5623 |
3
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 15] - a[offa + 31]; |
| 5624 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y3r = x0r + x2r; |
| 5625 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y3i = x0i + x2i; |
| 5626 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y7r = x0r - x2r; |
| 5627 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y7i = x0i - x2i; |
| 5628 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5629 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5630 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y11r = wk1i * x0r - wk1r * x0i; |
| 5631 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y11i = wk1i * x0i + wk1r * x0r; |
| 5632 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = x1r + x3i; |
| 5633 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = x1i - x3r; |
| 5634 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
y15r = wk1r * x0r - wk1i * x0i; |
| 5635 |
3
1. cftf161 : Replaced double multiplication with division → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE 3. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
y15i = wk1r * x0i + wk1i * x0r; |
| 5636 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y12r - y14r; |
| 5637 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y12i - y14i; |
| 5638 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y12r + y14r; |
| 5639 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y12i + y14i; |
| 5640 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = y13r - y15r; |
| 5641 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x2i = y13i - y15i; |
| 5642 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x3r = y13r + y15r; |
| 5643 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x3i = y13i + y15i; |
| 5644 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 24] = x0r + x2r; |
| 5645 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 25] = x0i + x2i; |
| 5646 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 26] = x0r - x2r; |
| 5647 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 27] = x0i - x2i; |
| 5648 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 28] = x1r - x3i; |
| 5649 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 29] = x1i + x3r; |
| 5650 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 30] = x1r + x3i; |
| 5651 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 31] = x1i - x3r; |
| 5652 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y8r + y10r; |
| 5653 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y8i + y10i; |
| 5654 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y8r - y10r; |
| 5655 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y8i - y10i; |
| 5656 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = y9r + y11r; |
| 5657 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = y9i + y11i; |
| 5658 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = y9r - y11r; |
| 5659 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = y9i - y11i; |
| 5660 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 16] = x0r + x2r; |
| 5661 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 17] = x0i + x2i; |
| 5662 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 18] = x0r - x2r; |
| 5663 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 19] = x0i - x2i; |
| 5664 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 20] = x1r - x3i; |
| 5665 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 21] = x1i + x3r; |
| 5666 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 22] = x1r + x3i; |
| 5667 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 23] = x1i - x3r; |
| 5668 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y5r - y7i; |
| 5669 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y5i + y7r; |
| 5670 |
2
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5671 |
2
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5672 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y5r + y7i; |
| 5673 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y5i - y7r; |
| 5674 |
2
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
x3r = wn4r * (x0r - x0i); |
| 5675 |
2
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double multiplication with division → NO_COVERAGE |
x3i = wn4r * (x0i + x0r); |
| 5676 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y4r - y6i; |
| 5677 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y4i + y6r; |
| 5678 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y4r + y6i; |
| 5679 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y4i - y6r; |
| 5680 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 8] = x0r + x2r; |
| 5681 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 9] = x0i + x2i; |
| 5682 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 10] = x0r - x2r; |
| 5683 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 11] = x0i - x2i; |
| 5684 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 12] = x1r - x3i; |
| 5685 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 13] = x1i + x3r; |
| 5686 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 14] = x1r + x3i; |
| 5687 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 15] = x1i - x3r; |
| 5688 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y0r + y2r; |
| 5689 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y0i + y2i; |
| 5690 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y0r - y2r; |
| 5691 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y0i - y2i; |
| 5692 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = y1r + y3r; |
| 5693 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = y1i + y3i; |
| 5694 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = y1r - y3r; |
| 5695 |
1
1. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = y1i - y3i; |
| 5696 |
1
1. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 5697 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x2i; |
| 5698 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 2] = x0r - x2r; |
| 5699 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 3] = x0i - x2i; |
| 5700 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = x1r - x3i; |
| 5701 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 5] = x1i + x3r; |
| 5702 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 6] = x1r + x3i; |
| 5703 |
2
1. cftf161 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf161 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 7] = x1i - x3r; |
| 5704 | } | |
| 5705 | ||
| 5706 | private void cftf162(double[] a, int offa, double[] w, int startw) { | |
| 5707 | double wn4r, wk1r, wk1i, wk2r, wk2i, wk3r, wk3i, x0r, x0i, x1r, x1i, x2r, x2i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i, y8r, y8i, y9r, y9i, y10r, y10i, y11r, y11i, y12r, y12i, y13r, y13i, y14r, y14i, y15r, y15i; | |
| 5708 | ||
| 5709 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5710 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[startw + 4]; |
| 5711 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[startw + 5]; |
| 5712 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3r = w[startw + 6]; |
| 5713 |
2
1. cftf162 : removed negation → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk3i = -w[startw + 7]; |
| 5714 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk2r = w[startw + 8]; |
| 5715 |
1
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE |
wk2i = w[startw + 9]; |
| 5716 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[offa + 17]; |
| 5717 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = a[offa + 1] + a[offa + 16]; |
| 5718 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 8] - a[offa + 25]; |
| 5719 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 9] + a[offa + 24]; |
| 5720 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5721 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5722 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y0r = x1r + x2r; |
| 5723 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = x1i + x2i; |
| 5724 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y4r = x1r - x2r; |
| 5725 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y4i = x1i - x2i; |
| 5726 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = a[offa] + a[offa + 17]; |
| 5727 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[offa + 16]; |
| 5728 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 8] + a[offa + 25]; |
| 5729 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 9] - a[offa + 24]; |
| 5730 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5731 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5732 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y8r = x1r - x2i; |
| 5733 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y8i = x1i + x2r; |
| 5734 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y12r = x1r + x2i; |
| 5735 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y12i = x1i - x2r; |
| 5736 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 2] - a[offa + 19]; |
| 5737 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 3] + a[offa + 18]; |
| 5738 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = wk1r * x0r - wk1i * x0i; |
| 5739 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = wk1r * x0i + wk1i * x0r; |
| 5740 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 10] - a[offa + 27]; |
| 5741 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 11] + a[offa + 26]; |
| 5742 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = wk3i * x0r - wk3r * x0i; |
| 5743 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = wk3i * x0i + wk3r * x0r; |
| 5744 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y1r = x1r + x2r; |
| 5745 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y1i = x1i + x2i; |
| 5746 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y5r = x1r - x2r; |
| 5747 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y5i = x1i - x2i; |
| 5748 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 2] + a[offa + 19]; |
| 5749 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 3] - a[offa + 18]; |
| 5750 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = wk3r * x0r - wk3i * x0i; |
| 5751 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = wk3r * x0i + wk3i * x0r; |
| 5752 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 10] + a[offa + 27]; |
| 5753 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 11] - a[offa + 26]; |
| 5754 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = wk1r * x0r + wk1i * x0i; |
| 5755 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2i = wk1r * x0i - wk1i * x0r; |
| 5756 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y9r = x1r - x2r; |
| 5757 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y9i = x1i - x2i; |
| 5758 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y13r = x1r + x2r; |
| 5759 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y13i = x1i + x2i; |
| 5760 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 4] - a[offa + 21]; |
| 5761 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 5] + a[offa + 20]; |
| 5762 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = wk2r * x0r - wk2i * x0i; |
| 5763 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = wk2r * x0i + wk2i * x0r; |
| 5764 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 12] - a[offa + 29]; |
| 5765 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 13] + a[offa + 28]; |
| 5766 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = wk2i * x0r - wk2r * x0i; |
| 5767 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = wk2i * x0i + wk2r * x0r; |
| 5768 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y2r = x1r + x2r; |
| 5769 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y2i = x1i + x2i; |
| 5770 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y6r = x1r - x2r; |
| 5771 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y6i = x1i - x2i; |
| 5772 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 4] + a[offa + 21]; |
| 5773 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 5] - a[offa + 20]; |
| 5774 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = wk2i * x0r - wk2r * x0i; |
| 5775 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = wk2i * x0i + wk2r * x0r; |
| 5776 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 12] + a[offa + 29]; |
| 5777 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 13] - a[offa + 28]; |
| 5778 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = wk2r * x0r - wk2i * x0i; |
| 5779 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = wk2r * x0i + wk2i * x0r; |
| 5780 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y10r = x1r - x2r; |
| 5781 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y10i = x1i - x2i; |
| 5782 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y14r = x1r + x2r; |
| 5783 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y14i = x1i + x2i; |
| 5784 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 6] - a[offa + 23]; |
| 5785 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 7] + a[offa + 22]; |
| 5786 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = wk3r * x0r - wk3i * x0i; |
| 5787 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = wk3r * x0i + wk3i * x0r; |
| 5788 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 14] - a[offa + 31]; |
| 5789 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 15] + a[offa + 30]; |
| 5790 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = wk1i * x0r - wk1r * x0i; |
| 5791 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = wk1i * x0i + wk1r * x0r; |
| 5792 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y3r = x1r + x2r; |
| 5793 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y3i = x1i + x2i; |
| 5794 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y7r = x1r - x2r; |
| 5795 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y7i = x1i - x2i; |
| 5796 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 6] + a[offa + 23]; |
| 5797 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 7] - a[offa + 22]; |
| 5798 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = wk1i * x0r + wk1r * x0i; |
| 5799 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = wk1i * x0i - wk1r * x0r; |
| 5800 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 14] + a[offa + 31]; |
| 5801 |
3
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 15] - a[offa + 30]; |
| 5802 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = wk3i * x0r - wk3r * x0i; |
| 5803 |
3
1. cftf162 : Replaced double multiplication with division → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE 3. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = wk3i * x0i + wk3r * x0r; |
| 5804 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y11r = x1r + x2r; |
| 5805 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
y11i = x1i + x2i; |
| 5806 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y15r = x1r - x2r; |
| 5807 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
y15i = x1i - x2i; |
| 5808 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y0r + y2r; |
| 5809 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y0i + y2i; |
| 5810 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = y1r + y3r; |
| 5811 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = y1i + y3i; |
| 5812 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x1r + x2r; |
| 5813 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x1i + x2i; |
| 5814 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 2] = x1r - x2r; |
| 5815 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 3] = x1i - x2i; |
| 5816 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y0r - y2r; |
| 5817 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y0i - y2i; |
| 5818 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = y1r - y3r; |
| 5819 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2i = y1i - y3i; |
| 5820 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = x1r - x2i; |
| 5821 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 5] = x1i + x2r; |
| 5822 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 6] = x1r + x2i; |
| 5823 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 7] = x1i - x2r; |
| 5824 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y4r - y6i; |
| 5825 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y4i + y6r; |
| 5826 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y5r - y7i; |
| 5827 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y5i + y7r; |
| 5828 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5829 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5830 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 8] = x1r + x2r; |
| 5831 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 9] = x1i + x2i; |
| 5832 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 10] = x1r - x2r; |
| 5833 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 11] = x1i - x2i; |
| 5834 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y4r + y6i; |
| 5835 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y4i - y6r; |
| 5836 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y5r + y7i; |
| 5837 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y5i - y7r; |
| 5838 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5839 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5840 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 12] = x1r - x2i; |
| 5841 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 13] = x1i + x2r; |
| 5842 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 14] = x1r + x2i; |
| 5843 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 15] = x1i - x2r; |
| 5844 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y8r + y10r; |
| 5845 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y8i + y10i; |
| 5846 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2r = y9r - y11r; |
| 5847 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x2i = y9i - y11i; |
| 5848 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 16] = x1r + x2r; |
| 5849 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 17] = x1i + x2i; |
| 5850 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 18] = x1r - x2r; |
| 5851 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 19] = x1i - x2i; |
| 5852 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y8r - y10r; |
| 5853 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y8i - y10i; |
| 5854 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = y9r + y11r; |
| 5855 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = y9i + y11i; |
| 5856 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 20] = x1r - x2i; |
| 5857 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 21] = x1i + x2r; |
| 5858 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 22] = x1r + x2i; |
| 5859 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 23] = x1i - x2r; |
| 5860 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y12r - y14i; |
| 5861 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y12i + y14r; |
| 5862 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y13r + y15i; |
| 5863 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y13i - y15r; |
| 5864 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5865 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5866 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 24] = x1r + x2r; |
| 5867 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 25] = x1i + x2i; |
| 5868 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 26] = x1r - x2r; |
| 5869 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 27] = x1i - x2i; |
| 5870 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y12r + y14i; |
| 5871 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y12i - y14r; |
| 5872 |
1
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y13r - y15i; |
| 5873 |
1
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y13i + y15r; |
| 5874 |
2
1. cftf162 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2r = wn4r * (x0r - x0i); |
| 5875 |
2
1. cftf162 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double multiplication with division → NO_COVERAGE |
x2i = wn4r * (x0i + x0r); |
| 5876 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 28] = x1r - x2i; |
| 5877 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 29] = x1i + x2r; |
| 5878 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 30] = x1r + x2i; |
| 5879 |
2
1. cftf162 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf162 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 31] = x1i - x2r; |
| 5880 | } | |
| 5881 | ||
| 5882 | private void cftf081(double[] a, int offa, double[] w, int startw) { | |
| 5883 | double wn4r, x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i; | |
| 5884 | ||
| 5885 |
1
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5886 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[offa + 8]; |
| 5887 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[offa + 9]; |
| 5888 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[offa + 8]; |
| 5889 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[offa + 9]; |
| 5890 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 4] + a[offa + 12]; |
| 5891 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 5] + a[offa + 13]; |
| 5892 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 4] - a[offa + 12]; |
| 5893 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 5] - a[offa + 13]; |
| 5894 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y0r = x0r + x2r; |
| 5895 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = x0i + x2i; |
| 5896 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y2r = x0r - x2r; |
| 5897 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y2i = x0i - x2i; |
| 5898 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y1r = x1r - x3i; |
| 5899 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y1i = x1i + x3r; |
| 5900 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y3r = x1r + x3i; |
| 5901 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y3i = x1i - x3r; |
| 5902 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 2] + a[offa + 10]; |
| 5903 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 3] + a[offa + 11]; |
| 5904 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa + 2] - a[offa + 10]; |
| 5905 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 3] - a[offa + 11]; |
| 5906 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 6] + a[offa + 14]; |
| 5907 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 7] + a[offa + 15]; |
| 5908 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 6] - a[offa + 14]; |
| 5909 |
3
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 7] - a[offa + 15]; |
| 5910 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y4r = x0r + x2r; |
| 5911 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
y4i = x0i + x2i; |
| 5912 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y6r = x0r - x2r; |
| 5913 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
y6i = x0i - x2i; |
| 5914 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = x1r - x3i; |
| 5915 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = x1i + x3r; |
| 5916 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = x1r + x3i; |
| 5917 |
1
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
x2i = x1i - x3r; |
| 5918 |
2
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf081 : Replaced double multiplication with division → NO_COVERAGE |
y5r = wn4r * (x0r - x0i); |
| 5919 |
2
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double multiplication with division → NO_COVERAGE |
y5i = wn4r * (x0r + x0i); |
| 5920 |
2
1. cftf081 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf081 : Replaced double multiplication with division → NO_COVERAGE |
y7r = wn4r * (x2r - x2i); |
| 5921 |
2
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double multiplication with division → NO_COVERAGE |
y7i = wn4r * (x2r + x2i); |
| 5922 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 8] = y1r + y5r; |
| 5923 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 9] = y1i + y5i; |
| 5924 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 10] = y1r - y5r; |
| 5925 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 11] = y1i - y5i; |
| 5926 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 12] = y3r - y7i; |
| 5927 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 13] = y3i + y7r; |
| 5928 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 14] = y3r + y7i; |
| 5929 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 15] = y3i - y7r; |
| 5930 |
1
1. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = y0r + y4r; |
| 5931 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = y0i + y4i; |
| 5932 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 2] = y0r - y4r; |
| 5933 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 3] = y0i - y4i; |
| 5934 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = y2r - y6i; |
| 5935 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 5] = y2i + y6r; |
| 5936 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 6] = y2r + y6i; |
| 5937 |
2
1. cftf081 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf081 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 7] = y2i - y6r; |
| 5938 | } | |
| 5939 | ||
| 5940 | private void cftf082(double[] a, int offa, double[] w, int startw) { | |
| 5941 | double wn4r, wk1r, wk1i, x0r, x0i, x1r, x1i, y0r, y0i, y1r, y1i, y2r, y2i, y3r, y3i, y4r, y4i, y5r, y5i, y6r, y6i, y7r, y7i; | |
| 5942 | ||
| 5943 |
1
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE |
wn4r = w[startw + 1]; |
| 5944 |
1
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1r = w[startw + 2]; |
| 5945 |
1
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE |
wk1i = w[startw + 3]; |
| 5946 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y0r = a[offa] - a[offa + 9]; |
| 5947 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y0i = a[offa + 1] + a[offa + 8]; |
| 5948 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y1r = a[offa] + a[offa + 9]; |
| 5949 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y1i = a[offa + 1] - a[offa + 8]; |
| 5950 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 4] - a[offa + 13]; |
| 5951 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 5] + a[offa + 12]; |
| 5952 |
2
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE |
y2r = wn4r * (x0r - x0i); |
| 5953 |
2
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE |
y2i = wn4r * (x0i + x0r); |
| 5954 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 4] + a[offa + 13]; |
| 5955 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 5] - a[offa + 12]; |
| 5956 |
2
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE |
y3r = wn4r * (x0r - x0i); |
| 5957 |
2
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE |
y3i = wn4r * (x0i + x0r); |
| 5958 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 2] - a[offa + 11]; |
| 5959 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 3] + a[offa + 10]; |
| 5960 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y4r = wk1r * x0r - wk1i * x0i; |
| 5961 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y4i = wk1r * x0i + wk1i * x0r; |
| 5962 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 2] + a[offa + 11]; |
| 5963 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 3] - a[offa + 10]; |
| 5964 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y5r = wk1i * x0r - wk1r * x0i; |
| 5965 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y5i = wk1i * x0i + wk1r * x0r; |
| 5966 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa + 6] - a[offa + 15]; |
| 5967 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 7] + a[offa + 14]; |
| 5968 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y6r = wk1i * x0r - wk1r * x0i; |
| 5969 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y6i = wk1i * x0i + wk1r * x0r; |
| 5970 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa + 6] + a[offa + 15]; |
| 5971 |
3
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 7] - a[offa + 14]; |
| 5972 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
y7r = wk1r * x0r - wk1i * x0i; |
| 5973 |
3
1. cftf082 : Replaced double multiplication with division → NO_COVERAGE 2. cftf082 : Replaced double multiplication with division → NO_COVERAGE 3. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
y7i = wk1r * x0i + wk1i * x0r; |
| 5974 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y0r + y2r; |
| 5975 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y0i + y2i; |
| 5976 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y4r + y6r; |
| 5977 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y4i + y6i; |
| 5978 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x1r; |
| 5979 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x1i; |
| 5980 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 2] = x0r - x1r; |
| 5981 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 3] = x0i - x1i; |
| 5982 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y0r - y2r; |
| 5983 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y0i - y2i; |
| 5984 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y4r - y6r; |
| 5985 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y4i - y6i; |
| 5986 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = x0r - x1i; |
| 5987 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 5] = x0i + x1r; |
| 5988 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 6] = x0r + x1i; |
| 5989 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 7] = x0i - x1r; |
| 5990 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = y1r - y3i; |
| 5991 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = y1i + y3r; |
| 5992 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = y5r - y7r; |
| 5993 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = y5i - y7i; |
| 5994 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 8] = x0r + x1r; |
| 5995 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 9] = x0i + x1i; |
| 5996 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 10] = x0r - x1r; |
| 5997 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 11] = x0i - x1i; |
| 5998 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = y1r + y3i; |
| 5999 |
1
1. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = y1i - y3r; |
| 6000 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x1r = y5r + y7r; |
| 6001 |
1
1. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
x1i = y5i + y7i; |
| 6002 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 12] = x0r - x1i; |
| 6003 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 13] = x0i + x1r; |
| 6004 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 14] = x0r + x1i; |
| 6005 |
2
1. cftf082 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf082 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 15] = x0i - x1r; |
| 6006 | } | |
| 6007 | ||
| 6008 | private void cftf040(double[] a, int offa) { | |
| 6009 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i; | |
| 6010 | ||
| 6011 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[offa + 4]; |
| 6012 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[offa + 5]; |
| 6013 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[offa + 4]; |
| 6014 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[offa + 5]; |
| 6015 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 2] + a[offa + 6]; |
| 6016 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 3] + a[offa + 7]; |
| 6017 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 2] - a[offa + 6]; |
| 6018 |
3
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 3] - a[offa + 7]; |
| 6019 |
1
1. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 6020 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x2i; |
| 6021 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 2] = x1r - x3i; |
| 6022 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 3] = x1i + x3r; |
| 6023 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = x0r - x2r; |
| 6024 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 5] = x0i - x2i; |
| 6025 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 6] = x1r + x3i; |
| 6026 |
2
1. cftf040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftf040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 7] = x1i - x3r; |
| 6027 | } | |
| 6028 | ||
| 6029 | private void cftb040(double[] a, int offa) { | |
| 6030 | double x0r, x0i, x1r, x1i, x2r, x2i, x3r, x3i; | |
| 6031 | ||
| 6032 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
x0r = a[offa] + a[offa + 4]; |
| 6033 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[offa + 5]; |
| 6034 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
x1r = a[offa] - a[offa + 4]; |
| 6035 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
x1i = a[offa + 1] - a[offa + 5]; |
| 6036 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
x2r = a[offa + 2] + a[offa + 6]; |
| 6037 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
x2i = a[offa + 3] + a[offa + 7]; |
| 6038 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
x3r = a[offa + 2] - a[offa + 6]; |
| 6039 |
3
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
x3i = a[offa + 3] - a[offa + 7]; |
| 6040 |
1
1. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] = x0r + x2r; |
| 6041 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] = x0i + x2i; |
| 6042 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 2] = x1r + x3i; |
| 6043 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 3] = x1i - x3r; |
| 6044 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 4] = x0r - x2r; |
| 6045 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 5] = x0i - x2i; |
| 6046 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 6] = x1r - x3i; |
| 6047 |
2
1. cftb040 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftb040 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 7] = x1i + x3r; |
| 6048 | } | |
| 6049 | ||
| 6050 | private void cftx020(double[] a, int offa) { | |
| 6051 | double x0r, x0i; | |
| 6052 |
2
1. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftx020 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa] - a[offa + 2]; |
| 6053 |
4
1. cftx020 : removed negation → NO_COVERAGE 2. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 4. cftx020 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = -a[offa + 1] + a[offa + 3]; |
| 6054 |
2
1. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftx020 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] += a[offa + 2]; |
| 6055 |
3
1. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftx020 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] += a[offa + 3]; |
| 6056 |
1
1. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x0r; |
| 6057 |
1
1. cftx020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x0i; |
| 6058 | } | |
| 6059 | ||
| 6060 | private void cftxb020(double[] a, int offa) { | |
| 6061 | double x0r, x0i; | |
| 6062 | ||
| 6063 |
2
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxb020 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa] - a[offa + 2]; |
| 6064 |
3
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftxb020 : Replaced double subtraction with addition → NO_COVERAGE |
x0i = a[offa + 1] - a[offa + 3]; |
| 6065 |
2
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxb020 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] += a[offa + 2]; |
| 6066 |
3
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftxb020 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa + 1] += a[offa + 3]; |
| 6067 |
1
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x0r; |
| 6068 |
1
1. cftxb020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x0i; |
| 6069 | } | |
| 6070 | ||
| 6071 | private void cftxc020(double[] a, int offa) { | |
| 6072 | double x0r, x0i; | |
| 6073 |
2
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxc020 : Replaced double subtraction with addition → NO_COVERAGE |
x0r = a[offa] - a[offa + 2]; |
| 6074 |
3
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftxc020 : Replaced double addition with subtraction → NO_COVERAGE |
x0i = a[offa + 1] + a[offa + 3]; |
| 6075 |
2
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxc020 : Replaced double addition with subtraction → NO_COVERAGE |
a[offa] += a[offa + 2]; |
| 6076 |
3
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 2. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE 3. cftxc020 : Replaced double subtraction with addition → NO_COVERAGE |
a[offa + 1] -= a[offa + 3]; |
| 6077 |
1
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 2] = x0r; |
| 6078 |
1
1. cftxc020 : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + 3] = x0i; |
| 6079 | } | |
| 6080 | ||
| 6081 | private void rftfsub(int n, double[] a, int offa, int nc, double[] c, int startc) { | |
| 6082 | int k, kk, ks, m; | |
| 6083 | double wkr, wki, xr, xi, yr, yi; | |
| 6084 | int idx1, idx2; | |
| 6085 | ||
| 6086 |
1
1. rftfsub : Replaced Shift Right with Shift Left → NO_COVERAGE |
m = n >> 1; |
| 6087 |
2
1. rftfsub : Replaced integer multiplication with division → NO_COVERAGE 2. rftfsub : Replaced integer division with multiplication → NO_COVERAGE |
ks = 2 * nc / m; |
| 6088 | kk = 0; | |
| 6089 |
2
1. rftfsub : changed conditional boundary → NO_COVERAGE 2. rftfsub : negated conditional → NO_COVERAGE |
for (int j = 2; j < m; j += 2) { |
| 6090 |
1
1. rftfsub : Replaced integer subtraction with addition → NO_COVERAGE |
k = n - j; |
| 6091 |
1
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE |
kk += ks; |
| 6092 |
3
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftfsub : Replaced integer subtraction with addition → NO_COVERAGE 3. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
wkr = 0.5 - c[startc + nc - kk]; |
| 6093 |
1
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE |
wki = c[startc + kk]; |
| 6094 |
1
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j; |
| 6095 |
1
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k; |
| 6096 |
1
1. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
xr = a[idx1] - a[idx2]; |
| 6097 |
3
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 3. rftfsub : Replaced double addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1] + a[idx2 + 1]; |
| 6098 |
3
1. rftfsub : Replaced double multiplication with division → NO_COVERAGE 2. rftfsub : Replaced double multiplication with division → NO_COVERAGE 3. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
yr = wkr * xr - wki * xi; |
| 6099 |
3
1. rftfsub : Replaced double multiplication with division → NO_COVERAGE 2. rftfsub : Replaced double multiplication with division → NO_COVERAGE 3. rftfsub : Replaced double addition with subtraction → NO_COVERAGE |
yi = wkr * xi + wki * xr; |
| 6100 |
1
1. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] -= yr; |
| 6101 |
3
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 3. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] = yi - a[idx1 + 1]; |
| 6102 |
1
1. rftfsub : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2] += yr; |
| 6103 |
3
1. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 3. rftfsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 1] = yi - a[idx2 + 1]; |
| 6104 | } | |
| 6105 |
5
1. rftfsub : removed negation → NO_COVERAGE 2. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 3. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 4. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE 5. rftfsub : Replaced integer addition with subtraction → NO_COVERAGE |
a[offa + m + 1] = -a[offa + m + 1]; |
| 6106 | } | |
| 6107 | ||
| 6108 | private void rftbsub(int n, double[] a, int offa, int nc, double[] c, int startc) { | |
| 6109 | int k, kk, ks, m; | |
| 6110 | double wkr, wki, xr, xi, yr, yi; | |
| 6111 | int idx1, idx2; | |
| 6112 | ||
| 6113 |
1
1. rftbsub : Replaced Shift Right with Shift Left → NO_COVERAGE |
m = n >> 1; |
| 6114 |
2
1. rftbsub : Replaced integer multiplication with division → NO_COVERAGE 2. rftbsub : Replaced integer division with multiplication → NO_COVERAGE |
ks = 2 * nc / m; |
| 6115 | kk = 0; | |
| 6116 |
2
1. rftbsub : changed conditional boundary → NO_COVERAGE 2. rftbsub : negated conditional → NO_COVERAGE |
for (int j = 2; j < m; j += 2) { |
| 6117 |
1
1. rftbsub : Replaced integer subtraction with addition → NO_COVERAGE |
k = n - j; |
| 6118 |
1
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE |
kk += ks; |
| 6119 |
3
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftbsub : Replaced integer subtraction with addition → NO_COVERAGE 3. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
wkr = 0.5 - c[startc + nc - kk]; |
| 6120 |
1
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE |
wki = c[startc + kk]; |
| 6121 |
1
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE |
idx1 = offa + j; |
| 6122 |
1
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE |
idx2 = offa + k; |
| 6123 |
1
1. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
xr = a[idx1] - a[idx2]; |
| 6124 |
3
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE 3. rftbsub : Replaced double addition with subtraction → NO_COVERAGE |
xi = a[idx1 + 1] + a[idx2 + 1]; |
| 6125 |
3
1. rftbsub : Replaced double multiplication with division → NO_COVERAGE 2. rftbsub : Replaced double multiplication with division → NO_COVERAGE 3. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
yr = wkr * xr - wki * xi; |
| 6126 |
3
1. rftbsub : Replaced double multiplication with division → NO_COVERAGE 2. rftbsub : Replaced double multiplication with division → NO_COVERAGE 3. rftbsub : Replaced double addition with subtraction → NO_COVERAGE |
yi = wkr * xi + wki * xr; |
| 6127 |
1
1. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1] -= yr; |
| 6128 |
2
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx1 + 1] -= yi; |
| 6129 |
1
1. rftbsub : Replaced double addition with subtraction → NO_COVERAGE |
a[idx2] += yr; |
| 6130 |
2
1. rftbsub : Replaced integer addition with subtraction → NO_COVERAGE 2. rftbsub : Replaced double subtraction with addition → NO_COVERAGE |
a[idx2 + 1] -= yi; |
| 6131 | } | |
| 6132 | } | |
| 6133 | ||
| 6134 | private void scale(final double m, final double[] a, int offa, boolean complex) { | |
| 6135 |
1
1. scale : Replaced double division with multiplication → KILLED |
final double norm = (1.0 / m); |
| 6136 | int n2; | |
| 6137 |
1
1. scale : negated conditional → KILLED |
if (complex) { |
| 6138 |
1
1. scale : Replaced integer multiplication with division → KILLED |
n2 = 2 * n; |
| 6139 | } else { | |
| 6140 | n2 = n; | |
| 6141 | } | |
| 6142 | { | |
| 6143 |
3
1. scale : changed conditional boundary → KILLED 2. scale : Replaced integer addition with subtraction → KILLED 3. scale : negated conditional → KILLED |
for (int i = offa; i < offa + n2; i++) { |
| 6144 |
1
1. scale : Replaced double multiplication with division → KILLED |
a[i] *= norm; |
| 6145 | } | |
| 6146 | ||
| 6147 | } | |
| 6148 | } | |
| 6149 | } | |
Mutations | ||
| 71 |
1.1 2.2 |
|
| 73 |
1.1 2.2 3.3 |
|
| 74 |
1.1 |
|
| 76 |
1.1 2.2 |
|
| 77 |
1.1 2.2 |
|
| 78 |
1.1 2.2 |
|
| 79 |
1.1 2.2 |
|
| 80 |
1.1 2.2 |
|
| 81 |
1.1 2.2 |
|
| 91 |
1.1 2.2 |
|
| 93 |
1.1 2.2 |
|
| 103 |
1.1 2.2 |
|
| 104 |
1.1 |
|
| 106 |
1.1 2.2 3.3 4.4 |
|
| 116 |
1.1 2.2 |
|
| 121 |
1.1 |
|
| 122 |
1.1 2.2 |
|
| 124 |
1.1 2.2 |
|
| 125 |
1.1 |
|
| 126 |
1.1 |
|
| 127 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 129 |
1.1 |
|
| 131 |
1.1 2.2 3.3 |
|
| 132 |
1.1 |
|
| 133 |
1.1 |
|
| 136 |
1.1 2.2 3.3 |
|
| 137 |
1.1 |
|
| 138 |
1.1 |
|
| 140 |
1.1 |
|
| 143 |
1.1 2.2 |
|
| 144 |
1.1 2.2 |
|
| 145 |
1.1 |
|
| 146 |
1.1 |
|
| 150 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 152 |
1.1 |
|
| 154 |
1.1 2.2 3.3 |
|
| 155 |
1.1 |
|
| 156 |
1.1 |
|
| 159 |
1.1 2.2 3.3 |
|
| 160 |
1.1 |
|
| 161 |
1.1 |
|
| 182 |
1.1 |
|
| 203 |
1.1 |
|
| 207 |
1.1 2.2 |
|
| 210 |
1.1 |
|
| 213 |
1.1 |
|
| 236 |
1.1 |
|
| 259 |
1.1 |
|
| 263 |
1.1 2.2 |
|
| 266 |
1.1 |
|
| 269 |
1.1 |
|
| 272 |
1.1 |
|
| 273 |
1.1 |
|
| 306 |
1.1 |
|
| 340 |
1.1 |
|
| 347 |
1.1 2.2 |
|
| 348 |
1.1 |
|
| 349 |
1.1 |
|
| 350 |
1.1 |
|
| 351 |
1.1 |
|
| 353 |
1.1 2.2 |
|
| 354 |
1.1 2.2 |
|
| 355 |
1.1 |
|
| 358 |
1.1 |
|
| 359 |
1.1 2.2 3.3 |
|
| 360 |
1.1 |
|
| 362 |
1.1 |
|
| 363 |
1.1 |
|
| 367 |
1.1 |
|
| 385 |
1.1 |
|
| 404 |
1.1 |
|
| 407 |
1.1 |
|
| 410 |
1.1 2.2 3.3 |
|
| 411 |
1.1 |
|
| 412 |
1.1 2.2 3.3 |
|
| 413 |
1.1 |
|
| 414 |
1.1 2.2 3.3 4.4 |
|
| 417 |
1.1 2.2 3.3 |
|
| 418 |
1.1 |
|
| 421 |
1.1 |
|
| 423 |
1.1 2.2 |
|
| 424 |
1.1 |
|
| 426 |
1.1 2.2 |
|
| 428 |
1.1 2.2 |
|
| 429 |
1.1 2.2 3.3 |
|
| 430 |
1.1 2.2 |
|
| 431 |
1.1 2.2 |
|
| 432 |
1.1 |
|
| 434 |
1.1 2.2 |
|
| 435 |
1.1 2.2 |
|
| 436 |
1.1 |
|
| 437 |
1.1 |
|
| 440 |
1.1 |
|
| 443 |
1.1 |
|
| 480 |
1.1 |
|
| 516 |
1.1 |
|
| 520 |
1.1 2.2 3.3 4.4 |
|
| 521 |
1.1 2.2 |
|
| 522 |
1.1 2.2 |
|
| 523 |
1.1 |
|
| 524 |
1.1 |
|
| 525 |
1.1 |
|
| 526 |
1.1 |
|
| 528 |
1.1 |
|
| 529 |
1.1 2.2 |
|
| 533 |
1.1 2.2 |
|
| 534 |
1.1 |
|
| 535 |
1.1 |
|
| 536 |
1.1 |
|
| 539 |
1.1 |
|
| 540 |
1.1 |
|
| 541 |
1.1 |
|
| 545 |
1.1 |
|
| 546 |
1.1 |
|
| 547 |
1.1 |
|
| 568 |
1.1 |
|
| 587 |
1.1 |
|
| 590 |
1.1 |
|
| 593 |
1.1 2.2 3.3 |
|
| 594 |
1.1 |
|
| 595 |
1.1 2.2 3.3 |
|
| 596 |
1.1 |
|
| 597 |
1.1 2.2 3.3 4.4 |
|
| 600 |
1.1 2.2 3.3 |
|
| 601 |
1.1 |
|
| 604 |
1.1 |
|
| 605 |
1.1 |
|
| 606 |
1.1 |
|
| 609 |
1.1 2.2 |
|
| 610 |
1.1 |
|
| 612 |
1.1 2.2 |
|
| 614 |
1.1 2.2 |
|
| 615 |
1.1 2.2 |
|
| 616 |
1.1 2.2 3.3 |
|
| 617 |
1.1 |
|
| 618 |
1.1 2.2 |
|
| 619 |
1.1 |
|
| 621 |
1.1 2.2 |
|
| 622 |
1.1 2.2 |
|
| 623 |
1.1 |
|
| 624 |
1.1 |
|
| 627 |
1.1 |
|
| 630 |
1.1 |
|
| 631 |
1.1 |
|
| 632 |
1.1 |
|
| 639 |
1.1 |
|
| 645 |
1.1 2.2 |
|
| 646 |
1.1 |
|
| 647 |
1.1 |
|
| 648 |
1.1 |
|
| 649 |
1.1 |
|
| 651 |
1.1 2.2 |
|
| 652 |
1.1 2.2 |
|
| 653 |
1.1 |
|
| 654 |
1.1 |
|
| 655 |
1.1 |
|
| 659 |
1.1 |
|
| 660 |
1.1 2.2 3.3 |
|
| 661 |
1.1 |
|
| 663 |
1.1 |
|
| 664 |
1.1 |
|
| 666 |
1.1 |
|
| 667 |
1.1 |
|
| 670 |
1.1 2.2 |
|
| 671 |
1.1 |
|
| 672 |
1.1 2.2 |
|
| 673 |
1.1 2.2 3.3 |
|
| 674 |
1.1 |
|
| 677 |
1.1 2.2 |
|
| 678 |
1.1 2.2 |
|
| 679 |
1.1 2.2 3.3 |
|
| 680 |
1.1 |
|
| 685 |
1.1 |
|
| 686 |
1.1 |
|
| 687 |
1.1 |
|
| 696 |
1.1 2.2 |
|
| 700 |
1.1 2.2 3.3 |
|
| 702 |
1.1 2.2 |
|
| 703 |
1.1 |
|
| 706 |
1.1 |
|
| 716 |
1.1 |
|
| 719 |
1.1 |
|
| 720 |
1.1 |
|
| 735 |
1.1 |
|
| 736 |
1.1 2.2 |
|
| 737 |
1.1 |
|
| 739 |
1.1 |
|
| 741 |
1.1 |
|
| 742 |
1.1 2.2 |
|
| 743 |
1.1 |
|
| 745 |
1.1 |
|
| 746 |
1.1 2.2 3.3 |
|
| 748 |
1.1 2.2 |
|
| 749 |
1.1 2.2 |
|
| 750 |
1.1 2.2 |
|
| 751 |
1.1 |
|
| 752 |
1.1 2.2 3.3 |
|
| 754 |
1.1 2.2 |
|
| 756 |
1.1 |
|
| 759 |
1.1 |
|
| 760 |
1.1 2.2 |
|
| 761 |
1.1 |
|
| 764 |
1.1 2.2 |
|
| 765 |
1.1 2.2 3.3 |
|
| 767 |
1.1 |
|
| 768 |
1.1 |
|
| 769 |
1.1 2.2 |
|
| 770 |
1.1 |
|
| 771 |
1.1 2.2 |
|
| 773 |
1.1 2.2 3.3 |
|
| 774 |
1.1 2.2 |
|
| 775 |
1.1 |
|
| 777 |
1.1 |
|
| 778 |
1.1 2.2 |
|
| 779 |
1.1 |
|
| 780 |
1.1 |
|
| 781 |
1.1 |
|
| 782 |
1.1 |
|
| 783 |
1.1 2.2 |
|
| 784 |
1.1 |
|
| 786 |
1.1 2.2 |
|
| 787 |
1.1 |
|
| 788 |
1.1 |
|
| 789 |
1.1 2.2 3.3 4.4 |
|
| 790 |
1.1 2.2 |
|
| 799 |
1.1 |
|
| 802 |
1.1 |
|
| 803 |
1.1 |
|
| 818 |
1.1 |
|
| 819 |
1.1 2.2 |
|
| 820 |
1.1 |
|
| 822 |
1.1 |
|
| 824 |
1.1 |
|
| 825 |
1.1 2.2 |
|
| 826 |
1.1 |
|
| 828 |
1.1 |
|
| 829 |
1.1 2.2 |
|
| 831 |
1.1 2.2 |
|
| 832 |
1.1 2.2 |
|
| 833 |
1.1 2.2 |
|
| 834 |
1.1 |
|
| 835 |
1.1 |
|
| 837 |
1.1 |
|
| 839 |
1.1 |
|
| 843 |
1.1 |
|
| 844 |
1.1 |
|
| 847 |
1.1 2.2 |
|
| 848 |
1.1 2.2 |
|
| 850 |
1.1 |
|
| 851 |
1.1 |
|
| 852 |
1.1 2.2 |
|
| 853 |
1.1 |
|
| 854 |
1.1 2.2 |
|
| 856 |
1.1 2.2 |
|
| 857 |
1.1 |
|
| 858 |
1.1 |
|
| 860 |
1.1 |
|
| 861 |
1.1 2.2 |
|
| 862 |
1.1 |
|
| 863 |
1.1 |
|
| 864 |
1.1 |
|
| 865 |
1.1 |
|
| 866 |
1.1 |
|
| 869 |
1.1 2.2 |
|
| 870 |
1.1 |
|
| 871 |
1.1 |
|
| 872 |
1.1 2.2 |
|
| 883 |
1.1 |
|
| 885 |
1.1 |
|
| 901 |
1.1 |
|
| 902 |
1.1 2.2 |
|
| 903 |
1.1 |
|
| 905 |
1.1 |
|
| 907 |
1.1 |
|
| 908 |
1.1 2.2 |
|
| 909 |
1.1 |
|
| 911 |
1.1 |
|
| 912 |
1.1 2.2 |
|
| 915 |
1.1 2.2 |
|
| 916 |
1.1 2.2 |
|
| 917 |
1.1 2.2 |
|
| 918 |
1.1 |
|
| 919 |
1.1 |
|
| 921 |
1.1 |
|
| 923 |
1.1 |
|
| 927 |
1.1 |
|
| 928 |
1.1 |
|
| 930 |
1.1 |
|
| 932 |
1.1 |
|
| 934 |
1.1 2.2 |
|
| 935 |
1.1 2.2 |
|
| 937 |
1.1 |
|
| 938 |
1.1 |
|
| 939 |
1.1 |
|
| 940 |
1.1 2.2 |
|
| 941 |
1.1 |
|
| 943 |
1.1 |
|
| 946 |
1.1 2.2 |
|
| 947 |
1.1 |
|
| 948 |
1.1 |
|
| 949 |
1.1 |
|
| 950 |
1.1 |
|
| 951 |
1.1 |
|
| 952 |
1.1 |
|
| 954 |
1.1 |
|
| 963 |
1.1 |
|
| 966 |
1.1 2.2 |
|
| 967 |
1.1 2.2 3.3 |
|
| 968 |
1.1 2.2 3.3 |
|
| 969 |
1.1 2.2 |
|
| 970 |
1.1 |
|
| 971 |
1.1 |
|
| 972 |
1.1 2.2 |
|
| 974 |
1.1 |
|
| 975 |
1.1 |
|
| 976 |
1.1 |
|
| 977 |
1.1 2.2 3.3 |
|
| 978 |
1.1 |
|
| 979 |
1.1 2.2 3.3 |
|
| 980 |
1.1 2.2 |
|
| 981 |
1.1 2.2 3.3 4.4 |
|
| 983 |
1.1 2.2 |
|
| 993 |
1.1 2.2 |
|
| 994 |
1.1 |
|
| 995 |
1.1 |
|
| 996 |
1.1 |
|
| 997 |
1.1 |
|
| 1000 |
1.1 |
|
| 1003 |
1.1 2.2 |
|
| 1004 |
1.1 |
|
| 1005 |
1.1 |
|
| 1006 |
1.1 2.2 |
|
| 1007 |
1.1 2.2 |
|
| 1008 |
1.1 |
|
| 1009 |
1.1 |
|
| 1011 |
1.1 |
|
| 1012 |
1.1 |
|
| 1013 |
1.1 2.2 |
|
| 1017 |
1.1 2.2 |
|
| 1018 |
1.1 |
|
| 1019 |
1.1 |
|
| 1021 |
1.1 |
|
| 1022 |
1.1 |
|
| 1023 |
1.1 |
|
| 1024 |
1.1 |
|
| 1025 |
1.1 |
|
| 1026 |
1.1 |
|
| 1027 |
1.1 2.2 |
|
| 1028 |
1.1 |
|
| 1029 |
1.1 |
|
| 1030 |
1.1 2.2 |
|
| 1031 |
1.1 2.2 |
|
| 1032 |
1.1 2.2 |
|
| 1033 |
1.1 2.2 |
|
| 1034 |
1.1 |
|
| 1036 |
1.1 |
|
| 1037 |
1.1 |
|
| 1038 |
1.1 |
|
| 1040 |
1.1 |
|
| 1041 |
1.1 |
|
| 1042 |
1.1 |
|
| 1056 |
1.1 2.2 3.3 |
|
| 1057 |
1.1 |
|
| 1058 |
1.1 |
|
| 1059 |
1.1 2.2 |
|
| 1060 |
1.1 |
|
| 1061 |
1.1 |
|
| 1062 |
1.1 2.2 |
|
| 1073 |
1.1 2.2 |
|
| 1074 |
1.1 |
|
| 1075 |
1.1 |
|
| 1076 |
1.1 |
|
| 1077 |
1.1 2.2 |
|
| 1078 |
1.1 2.2 |
|
| 1079 |
1.1 |
|
| 1080 |
1.1 2.2 |
|
| 1081 |
1.1 2.2 3.3 |
|
| 1087 |
1.1 |
|
| 1089 |
1.1 2.2 |
|
| 1090 |
1.1 2.2 |
|
| 1091 |
1.1 |
|
| 1092 |
1.1 |
|
| 1093 |
1.1 |
|
| 1094 |
1.1 |
|
| 1095 |
1.1 2.2 3.3 |
|
| 1096 |
1.1 2.2 3.3 |
|
| 1099 |
1.1 2.2 |
|
| 1100 |
1.1 |
|
| 1101 |
1.1 |
|
| 1102 |
1.1 |
|
| 1103 |
1.1 |
|
| 1104 |
1.1 2.2 3.3 |
|
| 1105 |
1.1 2.2 3.3 4.4 |
|
| 1109 |
1.1 2.2 |
|
| 1111 |
1.1 2.2 |
|
| 1112 |
1.1 2.2 |
|
| 1113 |
1.1 |
|
| 1114 |
1.1 |
|
| 1115 |
1.1 2.2 3.3 4.4 |
|
| 1116 |
1.1 2.2 3.3 |
|
| 1120 |
1.1 2.2 |
|
| 1121 |
1.1 |
|
| 1122 |
1.1 |
|
| 1123 |
1.1 2.2 3.3 |
|
| 1124 |
1.1 2.2 3.3 |
|
| 1129 |
1.1 2.2 |
|
| 1130 |
1.1 2.2 |
|
| 1131 |
1.1 2.2 |
|
| 1132 |
1.1 |
|
| 1133 |
1.1 |
|
| 1134 |
1.1 |
|
| 1135 |
1.1 |
|
| 1136 |
1.1 2.2 3.3 |
|
| 1137 |
1.1 2.2 3.3 |
|
| 1140 |
1.1 2.2 |
|
| 1141 |
1.1 |
|
| 1142 |
1.1 |
|
| 1143 |
1.1 |
|
| 1144 |
1.1 |
|
| 1145 |
1.1 2.2 3.3 |
|
| 1146 |
1.1 2.2 3.3 4.4 |
|
| 1153 |
1.1 |
|
| 1155 |
1.1 2.2 |
|
| 1156 |
1.1 2.2 |
|
| 1157 |
1.1 |
|
| 1158 |
1.1 |
|
| 1159 |
1.1 |
|
| 1160 |
1.1 |
|
| 1161 |
1.1 |
|
| 1164 |
1.1 2.2 |
|
| 1165 |
1.1 |
|
| 1166 |
1.1 |
|
| 1167 |
1.1 |
|
| 1168 |
1.1 |
|
| 1169 |
1.1 2.2 |
|
| 1173 |
1.1 2.2 |
|
| 1175 |
1.1 2.2 |
|
| 1176 |
1.1 2.2 |
|
| 1177 |
1.1 |
|
| 1178 |
1.1 |
|
| 1179 |
1.1 2.2 3.3 4.4 |
|
| 1180 |
1.1 2.2 3.3 |
|
| 1184 |
1.1 2.2 |
|
| 1185 |
1.1 |
|
| 1186 |
1.1 |
|
| 1187 |
1.1 2.2 3.3 |
|
| 1188 |
1.1 2.2 3.3 |
|
| 1193 |
1.1 2.2 |
|
| 1195 |
1.1 2.2 |
|
| 1196 |
1.1 2.2 |
|
| 1197 |
1.1 |
|
| 1198 |
1.1 |
|
| 1199 |
1.1 2.2 3.3 4.4 |
|
| 1200 |
1.1 2.2 3.3 4.4 |
|
| 1203 |
1.1 2.2 |
|
| 1204 |
1.1 |
|
| 1205 |
1.1 |
|
| 1206 |
1.1 2.2 3.3 4.4 |
|
| 1207 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1214 |
1.1 |
|
| 1216 |
1.1 2.2 |
|
| 1217 |
1.1 |
|
| 1218 |
1.1 |
|
| 1219 |
1.1 |
|
| 1220 |
1.1 |
|
| 1221 |
1.1 2.2 |
|
| 1224 |
1.1 2.2 |
|
| 1226 |
1.1 2.2 |
|
| 1227 |
1.1 |
|
| 1228 |
1.1 |
|
| 1229 |
1.1 2.2 3.3 |
|
| 1230 |
1.1 2.2 3.3 |
|
| 1235 |
1.1 2.2 |
|
| 1237 |
1.1 2.2 |
|
| 1238 |
1.1 2.2 3.3 |
|
| 1239 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 1240 |
1.1 2.2 3.3 |
|
| 1241 |
1.1 |
|
| 1242 |
1.1 |
|
| 1243 |
1.1 2.2 3.3 4.4 |
|
| 1244 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1247 |
1.1 2.2 3.3 |
|
| 1248 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 |
|
| 1249 |
1.1 2.2 3.3 4.4 |
|
| 1250 |
1.1 |
|
| 1251 |
1.1 |
|
| 1252 |
1.1 2.2 3.3 4.4 |
|
| 1253 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1255 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 |
|
| 1261 |
1.1 |
|
| 1262 |
1.1 2.2 |
|
| 1263 |
1.1 |
|
| 1264 |
1.1 |
|
| 1266 |
1.1 2.2 3.3 |
|
| 1267 |
1.1 |
|
| 1268 |
1.1 |
|
| 1269 |
1.1 |
|
| 1270 |
1.1 |
|
| 1271 |
1.1 2.2 3.3 |
|
| 1272 |
1.1 2.2 3.3 |
|
| 1275 |
1.1 2.2 |
|
| 1276 |
1.1 2.2 3.3 4.4 |
|
| 1278 |
1.1 2.2 3.3 4.4 |
|
| 1279 |
1.1 |
|
| 1280 |
1.1 |
|
| 1281 |
1.1 2.2 3.3 |
|
| 1282 |
1.1 |
|
| 1283 |
1.1 2.2 3.3 |
|
| 1284 |
1.1 2.2 3.3 |
|
| 1288 |
1.1 |
|
| 1289 |
1.1 |
|
| 1291 |
1.1 2.2 3.3 4.4 |
|
| 1292 |
1.1 |
|
| 1293 |
1.1 |
|
| 1294 |
1.1 |
|
| 1295 |
1.1 |
|
| 1296 |
1.1 2.2 3.3 |
|
| 1297 |
1.1 2.2 3.3 |
|
| 1300 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 |
|
| 1301 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 |
|
| 1303 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 |
|
| 1304 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 8.8 9.9 |
|
| 1306 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1307 |
1.1 |
|
| 1308 |
1.1 |
|
| 1309 |
1.1 2.2 3.3 |
|
| 1310 |
1.1 |
|
| 1311 |
1.1 2.2 3.3 |
|
| 1312 |
1.1 2.2 3.3 |
|
| 1316 |
1.1 2.2 |
|
| 1319 |
1.1 2.2 |
|
| 1320 |
1.1 |
|
| 1321 |
1.1 |
|
| 1322 |
1.1 2.2 3.3 4.4 |
|
| 1323 |
1.1 2.2 3.3 |
|
| 1327 |
1.1 2.2 |
|
| 1329 |
1.1 2.2 |
|
| 1330 |
1.1 |
|
| 1331 |
1.1 |
|
| 1332 |
1.1 2.2 3.3 4.4 |
|
| 1338 |
1.1 |
|
| 1340 |
1.1 2.2 |
|
| 1341 |
1.1 |
|
| 1342 |
1.1 |
|
| 1343 |
1.1 |
|
| 1344 |
1.1 |
|
| 1345 |
1.1 |
|
| 1348 |
1.1 2.2 |
|
| 1350 |
1.1 2.2 |
|
| 1351 |
1.1 |
|
| 1352 |
1.1 |
|
| 1353 |
1.1 2.2 3.3 4.4 |
|
| 1354 |
1.1 2.2 3.3 |
|
| 1359 |
1.1 2.2 |
|
| 1361 |
1.1 2.2 |
|
| 1362 |
1.1 2.2 3.3 |
|
| 1363 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 1364 |
1.1 2.2 3.3 |
|
| 1365 |
1.1 |
|
| 1366 |
1.1 |
|
| 1367 |
1.1 2.2 3.3 4.4 |
|
| 1368 |
1.1 2.2 3.3 4.4 |
|
| 1371 |
1.1 2.2 3.3 |
|
| 1372 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 1373 |
1.1 2.2 3.3 4.4 |
|
| 1374 |
1.1 |
|
| 1375 |
1.1 |
|
| 1376 |
1.1 2.2 3.3 4.4 |
|
| 1377 |
1.1 2.2 3.3 4.4 |
|
| 1379 |
1.1 2.2 3.3 4.4 5.5 6.6 7.7 |
|
| 1387 |
1.1 |
|
| 1392 |
1.1 |
|
| 1393 |
1.1 |
|
| 1396 |
1.1 |
|
| 1397 |
1.1 2.2 |
|
| 1398 |
1.1 |
|
| 1399 |
1.1 2.2 |
|
| 1400 |
1.1 |
|
| 1401 |
1.1 |
|
| 1402 |
1.1 |
|
| 1403 |
1.1 2.2 3.3 |
|
| 1404 |
1.1 |
|
| 1407 |
1.1 |
|
| 1408 |
1.1 |
|
| 1410 |
1.1 |
|
| 1414 |
1.1 |
|
| 1415 |
1.1 |
|
| 1417 |
1.1 |
|
| 1421 |
1.1 |
|
| 1422 |
1.1 |
|
| 1424 |
1.1 |
|
| 1428 |
1.1 |
|
| 1429 |
1.1 |
|
| 1431 |
1.1 |
|
| 1435 |
1.1 |
|
| 1436 |
1.1 |
|
| 1437 |
1.1 |
|
| 1438 |
1.1 |
|
| 1441 |
1.1 |
|
| 1448 |
1.1 |
|
| 1450 |
1.1 |
|
| 1457 |
1.1 |
|
| 1462 |
1.1 |
|
| 1463 |
1.1 |
|
| 1467 |
1.1 2.2 |
|
| 1468 |
1.1 2.2 |
|
| 1469 |
1.1 |
|
| 1470 |
1.1 |
|
| 1471 |
1.1 |
|
| 1474 |
1.1 |
|
| 1475 |
1.1 |
|
| 1477 |
1.1 |
|
| 1479 |
1.1 |
|
| 1482 |
1.1 |
|
| 1483 |
1.1 |
|
| 1485 |
1.1 |
|
| 1487 |
1.1 |
|
| 1490 |
1.1 |
|
| 1491 |
1.1 |
|
| 1493 |
1.1 |
|
| 1495 |
1.1 |
|
| 1498 |
1.1 |
|
| 1499 |
1.1 |
|
| 1501 |
1.1 |
|
| 1503 |
1.1 |
|
| 1506 |
1.1 |
|
| 1507 |
1.1 |
|
| 1509 |
1.1 |
|
| 1511 |
1.1 |
|
| 1512 |
1.1 |
|
| 1516 |
1.1 2.2 3.3 |
|
| 1518 |
1.1 |
|
| 1520 |
1.1 |
|
| 1531 |
1.1 |
|
| 1532 |
1.1 |
|
| 1533 |
1.1 2.2 |
|
| 1534 |
1.1 2.2 |
|
| 1535 |
1.1 2.2 |
|
| 1536 |
1.1 2.2 |
|
| 1537 |
1.1 |
|
| 1542 |
1.1 |
|
| 1543 |
1.1 |
|
| 1545 |
1.1 2.2 |
|
| 1547 |
1.1 |
|
| 1548 |
1.1 2.2 |
|
| 1549 |
1.1 |
|
| 1550 |
1.1 |
|
| 1551 |
1.1 |
|
| 1552 |
1.1 |
|
| 1553 |
1.1 2.2 |
|
| 1554 |
1.1 |
|
| 1555 |
1.1 2.2 |
|
| 1556 |
1.1 2.2 |
|
| 1557 |
1.1 2.2 |
|
| 1558 |
1.1 2.2 |
|
| 1559 |
1.1 2.2 |
|
| 1561 |
1.1 |
|
| 1563 |
1.1 |
|
| 1566 |
1.1 |
|
| 1569 |
1.1 2.2 3.3 |
|
| 1570 |
1.1 2.2 3.3 |
|
| 1572 |
1.1 |
|
| 1573 |
1.1 2.2 |
|
| 1575 |
1.1 |
|
| 1576 |
1.1 2.2 |
|
| 1579 |
1.1 2.2 |
|
| 1582 |
1.1 |
|
| 1583 |
1.1 2.2 |
|
| 1584 |
1.1 |
|
| 1585 |
1.1 2.2 |
|
| 1586 |
1.1 2.2 3.3 |
|
| 1588 |
1.1 2.2 |
|
| 1589 |
1.1 |
|
| 1601 |
1.1 |
|
| 1602 |
1.1 2.2 |
|
| 1603 |
1.1 |
|
| 1604 |
1.1 |
|
| 1605 |
1.1 |
|
| 1606 |
1.1 |
|
| 1607 |
1.1 |
|
| 1608 |
1.1 2.2 3.3 |
|
| 1611 |
1.1 |
|
| 1612 |
1.1 2.2 |
|
| 1614 |
1.1 2.2 |
|
| 1616 |
1.1 |
|
| 1617 |
1.1 2.2 |
|
| 1618 |
1.1 |
|
| 1619 |
1.1 |
|
| 1620 |
1.1 |
|
| 1621 |
1.1 |
|
| 1622 |
1.1 2.2 |
|
| 1623 |
1.1 |
|
| 1624 |
1.1 2.2 |
|
| 1625 |
1.1 |
|
| 1626 |
1.1 |
|
| 1627 |
1.1 |
|
| 1628 |
1.1 |
|
| 1630 |
1.1 |
|
| 1631 |
1.1 |
|
| 1632 |
1.1 |
|
| 1633 |
1.1 |
|
| 1634 |
1.1 2.2 3.3 |
|
| 1635 |
1.1 |
|
| 1637 |
1.1 |
|
| 1639 |
1.1 |
|
| 1641 |
1.1 2.2 |
|
| 1642 |
1.1 |
|
| 1643 |
1.1 2.2 3.3 4.4 |
|
| 1644 |
1.1 2.2 3.3 |
|
| 1647 |
1.1 2.2 |
|
| 1650 |
1.1 2.2 |
|
| 1651 |
1.1 |
|
| 1652 |
1.1 |
|
| 1653 |
1.1 2.2 3.3 |
|
| 1654 |
1.1 2.2 |
|
| 1655 |
1.1 2.2 |
|
| 1656 |
1.1 2.2 |
|
| 1670 |
1.1 |
|
| 1672 |
1.1 |
|
| 1673 |
1.1 2.2 |
|
| 1674 |
1.1 |
|
| 1675 |
1.1 |
|
| 1676 |
1.1 2.2 3.3 |
|
| 1677 |
1.1 |
|
| 1678 |
1.1 |
|
| 1679 |
1.1 |
|
| 1683 |
1.1 |
|
| 1684 |
1.1 2.2 3.3 |
|
| 1685 |
1.1 2.2 3.3 4.4 |
|
| 1686 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1688 |
1.1 |
|
| 1690 |
1.1 2.2 |
|
| 1691 |
1.1 |
|
| 1692 |
1.1 |
|
| 1693 |
1.1 |
|
| 1694 |
1.1 |
|
| 1695 |
1.1 |
|
| 1696 |
1.1 |
|
| 1697 |
1.1 2.2 |
|
| 1698 |
1.1 |
|
| 1699 |
1.1 2.2 |
|
| 1700 |
1.1 2.2 |
|
| 1702 |
1.1 |
|
| 1704 |
1.1 |
|
| 1707 |
1.1 |
|
| 1708 |
1.1 |
|
| 1709 |
1.1 |
|
| 1710 |
1.1 |
|
| 1711 |
1.1 |
|
| 1712 |
1.1 |
|
| 1714 |
1.1 |
|
| 1716 |
1.1 |
|
| 1718 |
1.1 |
|
| 1721 |
1.1 2.2 3.3 |
|
| 1722 |
1.1 2.2 3.3 |
|
| 1723 |
1.1 2.2 3.3 |
|
| 1724 |
1.1 2.2 3.3 |
|
| 1725 |
1.1 |
|
| 1726 |
1.1 |
|
| 1727 |
1.1 2.2 |
|
| 1728 |
1.1 2.2 |
|
| 1729 |
1.1 2.2 |
|
| 1730 |
1.1 2.2 |
|
| 1732 |
1.1 |
|
| 1733 |
1.1 |
|
| 1734 |
1.1 |
|
| 1736 |
1.1 2.2 |
|
| 1737 |
1.1 |
|
| 1738 |
1.1 2.2 |
|
| 1739 |
1.1 |
|
| 1740 |
1.1 2.2 |
|
| 1741 |
1.1 |
|
| 1756 |
1.1 |
|
| 1758 |
1.1 2.2 |
|
| 1759 |
1.1 |
|
| 1760 |
1.1 2.2 |
|
| 1761 |
1.1 2.2 |
|
| 1764 |
1.1 2.2 |
|
| 1765 |
1.1 2.2 |
|
| 1766 |
1.1 |
|
| 1768 |
1.1 2.2 |
|
| 1769 |
1.1 2.2 3.3 4.4 |
|
| 1770 |
1.1 2.2 3.3 4.4 5.5 |
|
| 1772 |
1.1 |
|
| 1774 |
1.1 |
|
| 1775 |
1.1 2.2 |
|
| 1776 |
1.1 |
|
| 1777 |
1.1 |
|
| 1778 |
1.1 |
|
| 1779 |
1.1 |
|
| 1780 |
1.1 |
|
| 1781 |
1.1 |
|
| 1782 |
1.1 2.2 |
|
| 1783 |
1.1 |
|
| 1784 |
1.1 |
|
| 1785 |
1.1 |
|
| 1786 |
1.1 |
|
| 1787 |
1.1 |
|
| 1788 |
1.1 |
|
| 1789 |
1.1 |
|
| 1791 |
1.1 |
|
| 1793 |
1.1 |
|
| 1795 |
1.1 |
|
| 1798 |
1.1 |
|
| 1799 |
1.1 2.2 |
|
| 1800 |
1.1 |
|
| 1801 |
1.1 2.2 |
|
| 1802 |
1.1 2.2 |
|
| 1803 |
1.1 2.2 |
|
| 1804 |
1.1 |
|
| 1805 |
1.1 |
|
| 1806 |
1.1 |
|
| 1807 |
1.1 |
|
| 1809 |
1.1 2.2 |
|
| 1810 |
1.1 2.2 |
|
| 1812 |
1.1 |
|
| 1814 |
1.1 |
|
| 1817 |
1.1 |
|
| 1818 |
1.1 |
|
| 1819 |
1.1 |
|
| 1821 |
1.1 2.2 |
|
| 1822 |
1.1 |
|
| 1823 |
1.1 2.2 3.3 4.4 |
|
| 1824 |
1.1 2.2 3.3 |
|
| 1825 |
1.1 2.2 3.3 4.4 |
|
| 1826 |
1.1 2.2 3.3 |
|
| 1840 |
1.1 |
|
| 1841 |
1.1 |
|
| 1842 |
1.1 |
|
| 1843 |
1.1 2.2 |
|
| 1844 |
1.1 |
|
| 1845 |
1.1 |
|
| 1846 |
1.1 |
|
| 1847 |
1.1 |
|
| 1848 |
1.1 |
|
| 1849 |
1.1 |
|
| 1850 |
1.1 |
|
| 1851 |
1.1 |
|
| 1852 |
1.1 |
|
| 1853 |
1.1 |
|
| 1855 |
1.1 |
|
| 1856 |
1.1 |
|
| 1858 |
1.1 |
|
| 1859 |
1.1 2.2 |
|
| 1861 |
1.1 |
|
| 1862 |
1.1 2.2 3.3 4.4 |
|
| 1863 |
1.1 2.2 |
|
| 1864 |
1.1 |
|
| 1866 |
1.1 2.2 |
|
| 1868 |
1.1 |
|
| 1869 |
1.1 2.2 |
|
| 1870 |
1.1 |
|
| 1871 |
1.1 |
|
| 1872 |
1.1 |
|
| 1873 |
1.1 |
|
| 1874 |
1.1 |
|
| 1875 |
1.1 |
|
| 1876 |
1.1 |
|
| 1877 |
1.1 |
|
| 1878 |
1.1 2.2 |
|
| 1879 |
1.1 |
|
| 1880 |
1.1 2.2 |
|
| 1881 |
1.1 2.2 |
|
| 1882 |
1.1 2.2 |
|
| 1883 |
1.1 |
|
| 1885 |
1.1 |
|
| 1887 |
1.1 |
|
| 1890 |
1.1 |
|
| 1891 |
1.1 |
|
| 1892 |
1.1 |
|
| 1893 |
1.1 |
|
| 1894 |
1.1 |
|
| 1895 |
1.1 |
|
| 1896 |
1.1 |
|
| 1898 |
1.1 |
|
| 1900 |
1.1 |
|
| 1902 |
1.1 |
|
| 1904 |
1.1 |
|
| 1907 |
1.1 2.2 3.3 |
|
| 1908 |
1.1 2.2 3.3 |
|
| 1909 |
1.1 2.2 3.3 |
|
| 1910 |
1.1 2.2 3.3 |
|
| 1911 |
1.1 2.2 3.3 |
|
| 1912 |
1.1 2.2 3.3 |
|
| 1913 |
1.1 |
|
| 1914 |
1.1 |
|
| 1915 |
1.1 |
|
| 1916 |
1.1 |
|
| 1917 |
1.1 |
|
| 1918 |
1.1 |
|
| 1919 |
1.1 |
|
| 1920 |
1.1 |
|
| 1922 |
1.1 |
|
| 1923 |
1.1 |
|
| 1924 |
1.1 |
|
| 1925 |
1.1 |
|
| 1927 |
1.1 2.2 |
|
| 1928 |
1.1 2.2 |
|
| 1929 |
1.1 |
|
| 1930 |
1.1 |
|
| 1931 |
1.1 2.2 |
|
| 1932 |
1.1 2.2 |
|
| 1933 |
1.1 |
|
| 1934 |
1.1 |
|
| 1937 |
1.1 2.2 |
|
| 1940 |
1.1 2.2 |
|
| 1941 |
1.1 |
|
| 1942 |
1.1 |
|
| 1943 |
1.1 |
|
| 1944 |
1.1 |
|
| 1945 |
1.1 |
|
| 1946 |
1.1 |
|
| 1947 |
1.1 |
|
| 1948 |
1.1 |
|
| 1949 |
1.1 |
|
| 1950 |
1.1 |
|
| 1952 |
1.1 2.2 |
|
| 1953 |
1.1 2.2 |
|
| 1954 |
1.1 2.2 |
|
| 1955 |
1.1 2.2 |
|
| 1957 |
1.1 2.2 |
|
| 1958 |
1.1 2.2 |
|
| 1960 |
1.1 2.2 3.3 |
|
| 1961 |
1.1 2.2 3.3 |
|
| 1962 |
1.1 2.2 |
|
| 1963 |
1.1 2.2 |
|
| 1977 |
1.1 |
|
| 1978 |
1.1 |
|
| 1980 |
1.1 |
|
| 1981 |
1.1 2.2 |
|
| 1982 |
1.1 |
|
| 1983 |
1.1 |
|
| 1984 |
1.1 |
|
| 1985 |
1.1 |
|
| 1986 |
1.1 |
|
| 1987 |
1.1 |
|
| 1988 |
1.1 |
|
| 1989 |
1.1 |
|
| 1991 |
1.1 |
|
| 1992 |
1.1 |
|
| 1993 |
1.1 2.2 3.3 |
|
| 1994 |
1.1 2.2 3.3 |
|
| 1996 |
1.1 |
|
| 1997 |
1.1 |
|
| 1998 |
1.1 |
|
| 1999 |
1.1 |
|
| 2001 |
1.1 2.2 |
|
| 2002 |
1.1 2.2 |
|
| 2003 |
1.1 2.2 |
|
| 2004 |
1.1 2.2 |
|
| 2006 |
1.1 2.2 |
|
| 2008 |
1.1 |
|
| 2009 |
1.1 2.2 |
|
| 2010 |
1.1 |
|
| 2011 |
1.1 |
|
| 2012 |
1.1 |
|
| 2013 |
1.1 |
|
| 2014 |
1.1 |
|
| 2015 |
1.1 |
|
| 2016 |
1.1 |
|
| 2017 |
1.1 |
|
| 2018 |
1.1 2.2 |
|
| 2019 |
1.1 |
|
| 2020 |
1.1 2.2 |
|
| 2021 |
1.1 2.2 |
|
| 2022 |
1.1 2.2 |
|
| 2023 |
1.1 |
|
| 2025 |
1.1 |
|
| 2027 |
1.1 |
|
| 2030 |
1.1 |
|
| 2031 |
1.1 |
|
| 2032 |
1.1 |
|
| 2034 |
1.1 |
|
| 2035 |
1.1 |
|
| 2036 |
1.1 |
|
| 2037 |
1.1 |
|
| 2039 |
1.1 |
|
| 2041 |
1.1 |
|
| 2043 |
1.1 |
|
| 2045 |
1.1 |
|
| 2048 |
1.1 |
|
| 2049 |
1.1 |
|
| 2050 |
1.1 |
|
| 2051 |
1.1 |
|
| 2052 |
1.1 |
|
| 2053 |
1.1 |
|
| 2054 |
1.1 |
|
| 2055 |
1.1 |
|
| 2056 |
1.1 |
|
| 2057 |
1.1 |
|
| 2058 |
1.1 |
|
| 2059 |
1.1 |
|
| 2060 |
1.1 |
|
| 2061 |
1.1 |
|
| 2063 |
1.1 |
|
| 2064 |
1.1 |
|
| 2065 |
1.1 |
|
| 2066 |
1.1 |
|
| 2068 |
1.1 2.2 |
|
| 2069 |
1.1 |
|
| 2070 |
1.1 2.2 3.3 4.4 |
|
| 2071 |
1.1 2.2 3.3 |
|
| 2072 |
1.1 2.2 3.3 4.4 |
|
| 2073 |
1.1 2.2 3.3 |
|
| 2074 |
1.1 2.2 3.3 4.4 |
|
| 2075 |
1.1 2.2 3.3 |
|
| 2078 |
1.1 2.2 |
|
| 2081 |
1.1 2.2 |
|
| 2082 |
1.1 |
|
| 2083 |
1.1 |
|
| 2084 |
1.1 |
|
| 2085 |
1.1 |
|
| 2086 |
1.1 |
|
| 2087 |
1.1 |
|
| 2088 |
1.1 |
|
| 2089 |
1.1 |
|
| 2090 |
1.1 |
|
| 2091 |
1.1 |
|
| 2093 |
1.1 2.2 |
|
| 2094 |
1.1 2.2 |
|
| 2095 |
1.1 |
|
| 2096 |
1.1 |
|
| 2098 |
1.1 |
|
| 2099 |
1.1 |
|
| 2100 |
1.1 |
|
| 2101 |
1.1 |
|
| 2103 |
1.1 2.2 3.3 |
|
| 2104 |
1.1 2.2 3.3 4.4 |
|
| 2105 |
1.1 2.2 3.3 |
|
| 2106 |
1.1 2.2 3.3 4.4 |
|
| 2122 |
1.1 |
|
| 2123 |
1.1 |
|
| 2124 |
1.1 |
|
| 2126 |
1.1 |
|
| 2127 |
1.1 2.2 |
|
| 2128 |
1.1 |
|
| 2129 |
1.1 |
|
| 2130 |
1.1 |
|
| 2131 |
1.1 |
|
| 2132 |
1.1 |
|
| 2133 |
1.1 |
|
| 2134 |
1.1 |
|
| 2135 |
1.1 |
|
| 2136 |
1.1 |
|
| 2137 |
1.1 |
|
| 2138 |
1.1 2.2 |
|
| 2140 |
1.1 |
|
| 2141 |
1.1 |
|
| 2142 |
1.1 |
|
| 2143 |
1.1 |
|
| 2144 |
1.1 |
|
| 2146 |
1.1 |
|
| 2147 |
1.1 |
|
| 2148 |
1.1 |
|
| 2149 |
1.1 |
|
| 2151 |
1.1 2.2 3.3 |
|
| 2152 |
1.1 2.2 3.3 4.4 5.5 |
|
| 2153 |
1.1 2.2 3.3 4.4 |
|
| 2154 |
1.1 2.2 3.3 4.4 5.5 |
|
| 2155 |
1.1 2.2 3.3 4.4 |
|
| 2157 |
1.1 |
|
| 2159 |
1.1 2.2 |
|
| 2160 |
1.1 |
|
| 2161 |
1.1 |
|
| 2162 |
1.1 |
|
| 2163 |
1.1 |
|
| 2164 |
1.1 |
|
| 2165 |
1.1 |
|
| 2166 |
1.1 |
|
| 2167 |
1.1 |
|
| 2168 |
1.1 |
|
| 2169 |
1.1 |
|
| 2170 |
1.1 2.2 |
|
| 2171 |
1.1 2.2 |
|
| 2172 |
1.1 2.2 |
|
| 2173 |
1.1 2.2 |
|
| 2174 |
1.1 2.2 |
|
| 2175 |
1.1 |
|
| 2177 |
1.1 |
|
| 2179 |
1.1 |
|
| 2181 |
1.1 |
|
| 2184 |
1.1 |
|
| 2185 |
1.1 |
|
| 2186 |
1.1 |
|
| 2187 |
1.1 |
|
| 2189 |
1.1 |
|
| 2190 |
1.1 |
|
| 2191 |
1.1 |
|
| 2192 |
1.1 |
|
| 2193 |
1.1 |
|
| 2195 |
1.1 |
|
| 2197 |
1.1 |
|
| 2199 |
1.1 |
|
| 2201 |
1.1 |
|
| 2203 |
1.1 |
|
| 2206 |
1.1 2.2 3.3 |
|
| 2207 |
1.1 2.2 3.3 |
|
| 2208 |
1.1 2.2 3.3 |
|
| 2209 |
1.1 2.2 3.3 |
|
| 2210 |
1.1 2.2 3.3 |
|
| 2211 |
1.1 2.2 3.3 |
|
| 2212 |
1.1 2.2 3.3 |
|
| 2213 |
1.1 2.2 3.3 |
|
| 2215 |
1.1 |
|
| 2216 |
1.1 |
|
| 2217 |
1.1 |
|
| 2218 |
1.1 |
|
| 2219 |
1.1 |
|
| 2220 |
1.1 |
|
| 2221 |
1.1 |
|
| 2222 |
1.1 |
|
| 2224 |
1.1 2.2 3.3 4.4 |
|
| 2225 |
1.1 2.2 3.3 4.4 |
|
| 2226 |
1.1 2.2 3.3 4.4 |
|
| 2227 |
1.1 2.2 3.3 4.4 |
|
| 2228 |
1.1 2.2 3.3 |
|
| 2229 |
1.1 2.2 3.3 |
|
| 2230 |
1.1 2.2 3.3 |
|
| 2231 |
1.1 2.2 3.3 |
|
| 2233 |
1.1 |
|
| 2234 |
1.1 |
|
| 2235 |
1.1 |
|
| 2236 |
1.1 |
|
| 2237 |
1.1 |
|
| 2239 |
1.1 2.2 3.3 |
|
| 2240 |
1.1 2.2 |
|
| 2241 |
1.1 2.2 |
|
| 2242 |
1.1 2.2 |
|
| 2243 |
1.1 |
|
| 2244 |
1.1 |
|
| 2245 |
1.1 2.2 |
|
| 2246 |
1.1 2.2 |
|
| 2247 |
1.1 |
|
| 2248 |
1.1 |
|
| 2265 |
1.1 |
|
| 2266 |
1.1 |
|
| 2267 |
1.1 |
|
| 2269 |
1.1 |
|
| 2270 |
1.1 2.2 |
|
| 2271 |
1.1 |
|
| 2272 |
1.1 |
|
| 2273 |
1.1 |
|
| 2274 |
1.1 |
|
| 2275 |
1.1 |
|
| 2276 |
1.1 |
|
| 2277 |
1.1 |
|
| 2278 |
1.1 |
|
| 2279 |
1.1 |
|
| 2280 |
1.1 |
|
| 2281 |
1.1 2.2 |
|
| 2283 |
1.1 |
|
| 2285 |
1.1 2.2 |
|
| 2286 |
1.1 2.2 |
|
| 2287 |
1.1 2.2 |
|
| 2288 |
1.1 2.2 |
|
| 2289 |
1.1 2.2 3.3 4.4 |
|
| 2290 |
1.1 2.2 3.3 4.4 |
|
| 2291 |
1.1 2.2 3.3 |
|
| 2292 |
1.1 2.2 3.3 |
|
| 2294 |
1.1 2.2 3.3 |
|
| 2295 |
1.1 2.2 |
|
| 2296 |
1.1 2.2 |
|
| 2297 |
1.1 2.2 |
|
| 2298 |
1.1 2.2 |
|
| 2300 |
1.1 |
|
| 2302 |
1.1 2.2 |
|
| 2303 |
1.1 |
|
| 2304 |
1.1 |
|
| 2305 |
1.1 |
|
| 2306 |
1.1 |
|
| 2307 |
1.1 |
|
| 2308 |
1.1 |
|
| 2309 |
1.1 |
|
| 2310 |
1.1 |
|
| 2311 |
1.1 |
|
| 2312 |
1.1 |
|
| 2313 |
1.1 2.2 |
|
| 2314 |
1.1 |
|
| 2315 |
1.1 2.2 |
|
| 2316 |
1.1 2.2 |
|
| 2317 |
1.1 2.2 |
|
| 2318 |
1.1 2.2 |
|
| 2319 |
1.1 |
|
| 2321 |
1.1 |
|
| 2323 |
1.1 |
|
| 2325 |
1.1 |
|
| 2328 |
1.1 |
|
| 2329 |
1.1 |
|
| 2330 |
1.1 |
|
| 2332 |
1.1 |
|
| 2333 |
1.1 |
|
| 2334 |
1.1 |
|
| 2335 |
1.1 |
|
| 2336 |
1.1 |
|
| 2338 |
1.1 |
|
| 2340 |
1.1 |
|
| 2342 |
1.1 |
|
| 2344 |
1.1 |
|
| 2346 |
1.1 |
|
| 2349 |
1.1 |
|
| 2350 |
1.1 |
|
| 2351 |
1.1 |
|
| 2352 |
1.1 |
|
| 2353 |
1.1 |
|
| 2354 |
1.1 |
|
| 2355 |
1.1 |
|
| 2356 |
1.1 |
|
| 2358 |
1.1 2.2 3.3 4.4 |
|
| 2359 |
1.1 2.2 3.3 4.4 |
|
| 2360 |
1.1 2.2 3.3 4.4 |
|
| 2361 |
1.1 2.2 3.3 4.4 |
|
| 2362 |
1.1 2.2 3.3 |
|
| 2363 |
1.1 2.2 3.3 |
|
| 2364 |
1.1 2.2 3.3 |
|
| 2365 |
1.1 2.2 3.3 |
|
| 2366 |
1.1 |
|
| 2367 |
1.1 |
|
| 2368 |
1.1 |
|
| 2369 |
1.1 |
|
| 2370 |
1.1 |
|
| 2371 |
1.1 |
|
| 2372 |
1.1 |
|
| 2373 |
1.1 |
|
| 2375 |
1.1 |
|
| 2376 |
1.1 |
|
| 2377 |
1.1 |
|
| 2378 |
1.1 |
|
| 2379 |
1.1 |
|
| 2381 |
1.1 2.2 3.3 |
|
| 2382 |
1.1 2.2 |
|
| 2383 |
1.1 2.2 3.3 4.4 |
|
| 2384 |
1.1 2.2 3.3 |
|
| 2385 |
1.1 2.2 3.3 4.4 |
|
| 2386 |
1.1 2.2 3.3 |
|
| 2387 |
1.1 2.2 3.3 4.4 |
|
| 2388 |
1.1 2.2 3.3 |
|
| 2389 |
1.1 2.2 3.3 4.4 |
|
| 2390 |
1.1 2.2 3.3 |
|
| 2403 |
1.1 |
|
| 2406 |
1.1 2.2 |
|
| 2407 |
1.1 2.2 |
|
| 2408 |
1.1 |
|
| 2409 |
1.1 2.2 |
|
| 2410 |
1.1 2.2 |
|
| 2411 |
1.1 2.2 |
|
| 2412 |
1.1 2.2 |
|
| 2413 |
1.1 2.2 |
|
| 2414 |
1.1 2.2 |
|
| 2415 |
1.1 2.2 |
|
| 2418 |
1.1 2.2 |
|
| 2419 |
1.1 |
|
| 2420 |
1.1 2.2 |
|
| 2421 |
1.1 |
|
| 2422 |
1.1 |
|
| 2423 |
1.1 2.2 |
|
| 2424 |
1.1 2.2 |
|
| 2425 |
1.1 |
|
| 2426 |
1.1 |
|
| 2427 |
1.1 |
|
| 2428 |
1.1 |
|
| 2429 |
1.1 |
|
| 2431 |
1.1 2.2 |
|
| 2432 |
1.1 2.2 |
|
| 2433 |
1.1 |
|
| 2434 |
1.1 |
|
| 2435 |
1.1 |
|
| 2438 |
1.1 2.2 3.3 4.4 |
|
| 2439 |
1.1 2.2 3.3 |
|
| 2444 |
1.1 |
|
| 2445 |
1.1 2.2 |
|
| 2446 |
1.1 |
|
| 2447 |
1.1 2.2 |
|
| 2448 |
1.1 2.2 |
|
| 2449 |
1.1 |
|
| 2450 |
1.1 2.2 |
|
| 2451 |
1.1 2.2 |
|
| 2452 |
1.1 |
|
| 2453 |
1.1 |
|
| 2454 |
1.1 |
|
| 2456 |
1.1 2.2 |
|
| 2457 |
1.1 2.2 |
|
| 2458 |
1.1 |
|
| 2461 |
1.1 2.2 3.3 4.4 |
|
| 2462 |
1.1 2.2 3.3 |
|
| 2467 |
1.1 2.2 |
|
| 2468 |
1.1 2.2 |
|
| 2469 |
1.1 |
|
| 2470 |
1.1 2.2 |
|
| 2471 |
1.1 2.2 |
|
| 2472 |
1.1 2.2 |
|
| 2473 |
1.1 2.2 |
|
| 2474 |
1.1 2.2 |
|
| 2475 |
1.1 2.2 |
|
| 2476 |
1.1 |
|
| 2477 |
1.1 |
|
| 2478 |
1.1 |
|
| 2479 |
1.1 |
|
| 2480 |
1.1 |
|
| 2481 |
1.1 |
|
| 2482 |
1.1 |
|
| 2484 |
1.1 |
|
| 2487 |
1.1 2.2 |
|
| 2488 |
1.1 |
|
| 2490 |
1.1 2.2 |
|
| 2491 |
1.1 |
|
| 2496 |
1.1 2.2 |
|
| 2497 |
1.1 |
|
| 2498 |
1.1 2.2 |
|
| 2499 |
1.1 2.2 |
|
| 2500 |
1.1 2.2 |
|
| 2501 |
1.1 |
|
| 2502 |
1.1 |
|
| 2503 |
1.1 2.2 |
|
| 2504 |
1.1 2.2 |
|
| 2505 |
1.1 2.2 |
|
| 2506 |
1.1 |
|
| 2507 |
1.1 |
|
| 2508 |
1.1 |
|
| 2509 |
1.1 |
|
| 2510 |
1.1 |
|
| 2512 |
1.1 |
|
| 2515 |
1.1 2.2 |
|
| 2516 |
1.1 |
|
| 2517 |
1.1 2.2 |
|
| 2518 |
1.1 |
|
| 2524 |
1.1 |
|
| 2526 |
1.1 2.2 |
|
| 2527 |
1.1 |
|
| 2528 |
1.1 2.2 |
|
| 2529 |
1.1 2.2 |
|
| 2530 |
1.1 2.2 |
|
| 2531 |
1.1 2.2 |
|
| 2532 |
1.1 2.2 |
|
| 2533 |
1.1 |
|
| 2534 |
1.1 |
|
| 2538 |
1.1 2.2 |
|
| 2539 |
1.1 2.2 |
|
| 2545 |
1.1 2.2 |
|
| 2546 |
1.1 2.2 |
|
| 2547 |
1.1 |
|
| 2548 |
1.1 2.2 3.3 |
|
| 2549 |
1.1 2.2 3.3 |
|
| 2551 |
1.1 |
|
| 2552 |
1.1 |
|
| 2553 |
1.1 2.2 |
|
| 2554 |
1.1 |
|
| 2555 |
1.1 |
|
| 2556 |
1.1 2.2 3.3 4.4 |
|
| 2557 |
1.1 2.2 3.3 |
|
| 2563 |
1.1 2.2 |
|
| 2564 |
1.1 |
|
| 2565 |
1.1 2.2 3.3 |
|
| 2566 |
1.1 2.2 3.3 |
|
| 2568 |
1.1 |
|
| 2569 |
1.1 |
|
| 2570 |
1.1 2.2 |
|
| 2571 |
1.1 |
|
| 2572 |
1.1 |
|
| 2573 |
1.1 2.2 3.3 4.4 |
|
| 2574 |
1.1 2.2 3.3 4.4 |
|
| 2578 |
1.1 2.2 |
|
| 2579 |
1.1 |
|
| 2580 |
1.1 2.2 |
|
| 2581 |
1.1 2.2 3.3 4.4 |
|
| 2585 |
1.1 2.2 |
|
| 2586 |
1.1 2.2 |
|
| 2587 |
1.1 |
|
| 2588 |
1.1 |
|
| 2589 |
1.1 2.2 |
|
| 2590 |
1.1 2.2 3.3 4.4 |
|
| 2594 |
1.1 2.2 |
|
| 2595 |
1.1 2.2 |
|
| 2596 |
1.1 |
|
| 2597 |
1.1 2.2 3.3 4.4 5.5 |
|
| 2601 |
1.1 |
|
| 2602 |
1.1 2.2 |
|
| 2603 |
1.1 |
|
| 2604 |
1.1 |
|
| 2605 |
1.1 2.2 |
|
| 2606 |
1.1 2.2 |
|
| 2607 |
1.1 |
|
| 2608 |
1.1 2.2 |
|
| 2609 |
1.1 |
|
| 2610 |
1.1 |
|
| 2611 |
1.1 |
|
| 2612 |
1.1 |
|
| 2613 |
1.1 2.2 3.3 4.4 5.5 6.6 |
|
| 2614 |
1.1 2.2 3.3 |
|
| 2617 |
1.1 |
|
| 2619 |
1.1 2.2 |
|
| 2620 |
1.1 2.2 |
|
| 2621 |
1.1 |
|
| 2622 |
1.1 |
|
| 2623 |
1.1 2.2 |
|
| 2624 |
1.1 2.2 |
|
| 2625 |
1.1 |
|
| 2626 |
1.1 2.2 |
|
| 2627 |
1.1 |
|
| 2628 |
1.1 |
|
| 2629 |
1.1 2.2 |
|
| 2630 |
1.1 |
|
| 2631 |
1.1 |
|
| 2632 |
1.1 |
|
| 2633 |
1.1 |
|
| 2634 |
1.1 2.2 |
|
| 2635 |
1.1 2.2 3.3 |
|
| 2636 |
1.1 2.2 |
|
| 2637 |
1.1 2.2 |
|
| 2638 |
1.1 |
|
| 2640 |
1.1 |
|
| 2643 |
1.1 2.2 |
|
| 2644 |
1.1 2.2 |
|
| 2645 |
1.1 |
|
| 2646 |
1.1 |
|
| 2651 |
1.1 2.2 |
|
| 2652 |
1.1 |
|
| 2653 |
1.1 |
|
| 2654 |
1.1 2.2 |
|
| 2655 |
1.1 2.2 |
|
| 2656 |
1.1 |
|
| 2657 |
1.1 2.2 |
|
| 2658 |
1.1 |
|
| 2659 |
1.1 |
|
| 2660 |
1.1 |
|
| 2661 |
1.1 |
|
| 2662 |
1.1 2.2 |
|
| 2663 |
1.1 |
|
| 2664 |
1.1 |
|
| 2665 |
1.1 2.2 |
|
| 2666 |
1.1 2.2 3.3 |
|
| 2667 |
1.1 2.2 |
|
| 2668 |
1.1 2.2 |
|
| 2669 |
1.1 |
|
| 2671 |
1.1 |
|
| 2674 |
1.1 2.2 |
|
| 2675 |
1.1 2.2 |
|
| 2676 |
1.1 |
|
| 2677 |
1.1 |
|
| 2694 |
1.1 |
|
| 2697 |
1.1 2.2 |
|
| 2698 |
1.1 2.2 |
|
| 2699 |
1.1 |
|
| 2700 |
1.1 2.2 |
|
| 2701 |
1.1 2.2 |
|
| 2702 |
1.1 |
|
| 2703 |
1.1 |
|
| 2704 |
1.1 2.2 |
|
| 2705 |
1.1 2.2 3.3 4.4 |
|
| 2709 |
1.1 2.2 |
|
| 2710 |
1.1 |
|
| 2711 |
1.1 |
|
| 2712 |
1.1 2.2 |
|
| 2713 |
1.1 2.2 3.3 4.4 |
|
| 2717 |
1.1 2.2 |
|
| 2718 |
1.1 2.2 |
|
| 2719 |
1.1 |
|
| 2720 |
1.1 |
|
| 2721 |
1.1 2.2 |
|
| 2722 |
1.1 2.2 |
|
| 2723 |
1.1 |
|
| 2724 |
1.1 2.2 |
|
| 2725 |
1.1 |
|
| 2726 |
1.1 |
|
| 2727 |
1.1 2.2 3.3 |
|
| 2728 |
1.1 2.2 |
|
| 2732 |
1.1 2.2 3.3 |
|
| 2733 |
1.1 2.2 3.3 |
|
| 2737 |
1.1 |
|
| 2738 |
1.1 2.2 |
|
| 2739 |
1.1 2.2 |
|
| 2740 |
1.1 |
|
| 2741 |
1.1 2.2 |
|
| 2742 |
1.1 2.2 |
|
| 2743 |
1.1 2.2 |
|
| 2744 |
1.1 2.2 |
|
| 2745 |
1.1 2.2 |
|
| 2746 |
1.1 2.2 |
|
| 2747 |
1.1 2.2 3.3 |
|
| 2748 |
1.1 2.2 |
|
| 2749 |
1.1 |
|
| 2750 |
1.1 |
|
| 2751 |
1.1 |
|
| 2752 |
1.1 |
|
| 2753 |
1.1 |
|
| 2754 |
1.1 |
|
| 2755 |
1.1 |
|
| 2756 |
1.1 2.2 |
|
| 2757 |
1.1 |
|
| 2759 |
1.1 |
|
| 2762 |
1.1 2.2 |
|
| 2763 |
1.1 2.2 |
|
| 2764 |
1.1 |
|
| 2765 |
1.1 |
|
| 2770 |
1.1 2.2 |
|
| 2771 |
1.1 |
|
| 2772 |
1.1 2.2 |
|
| 2773 |
1.1 2.2 |
|
| 2774 |
1.1 2.2 |
|
| 2775 |
1.1 2.2 |
|
| 2776 |
1.1 |
|
| 2777 |
1.1 |
|
| 2778 |
1.1 |
|
| 2779 |
1.1 |
|
| 2780 |
1.1 2.2 |
|
| 2781 |
1.1 2.2 |
|
| 2782 |
1.1 2.2 |
|
| 2783 |
1.1 2.2 3.3 |
|
| 2784 |
1.1 |
|
| 2785 |
1.1 |
|
| 2786 |
1.1 |
|
| 2787 |
1.1 2.2 |
|
| 2788 |
1.1 |
|
| 2790 |
1.1 |
|
| 2793 |
1.1 2.2 |
|
| 2794 |
1.1 2.2 |
|
| 2795 |
1.1 |
|
| 2796 |
1.1 |
|
| 2805 |
1.1 2.2 |
|
| 2806 |
1.1 2.2 |
|
| 2807 |
1.1 |
|
| 2808 |
1.1 2.2 3.3 |
|
| 2809 |
1.1 2.2 3.3 |
|
| 2811 |
1.1 |
|
| 2812 |
1.1 |
|
| 2813 |
1.1 2.2 |
|
| 2814 |
1.1 |
|
| 2815 |
1.1 |
|
| 2816 |
1.1 2.2 3.3 4.4 |
|
| 2817 |
1.1 2.2 3.3 |
|
| 2823 |
1.1 2.2 |
|
| 2824 |
1.1 |
|
| 2825 |
1.1 2.2 3.3 |
|
| 2826 |
1.1 2.2 3.3 |
|
| 2828 |
1.1 |
|
| 2829 |
1.1 |
|
| 2830 |
1.1 2.2 |
|
| 2831 |
1.1 |
|
| 2832 |
1.1 |
|
| 2833 |
1.1 2.2 3.3 4.4 |
|
| 2834 |
1.1 2.2 3.3 4.4 |
|
| 2838 |
1.1 2.2 |
|
| 2839 |
1.1 |
|
| 2840 |
1.1 2.2 |
|
| 2841 |
1.1 |
|
| 2842 |
1.1 2.2 |
|
| 2845 |
1.1 2.2 |
|
| 2846 |
1.1 |
|
| 2847 |
1.1 2.2 |
|
| 2848 |
1.1 2.2 |
|
| 2849 |
1.1 2.2 |
|
| 2850 |
1.1 |
|
| 2851 |
1.1 |
|
| 2852 |
1.1 2.2 |
|
| 2853 |
1.1 2.2 |
|
| 2857 |
1.1 2.2 |
|
| 2858 |
1.1 2.2 |
|
| 2862 |
1.1 |
|
| 2864 |
1.1 2.2 |
|
| 2865 |
1.1 2.2 |
|
| 2866 |
1.1 |
|
| 2867 |
1.1 2.2 |
|
| 2868 |
1.1 2.2 |
|
| 2869 |
1.1 2.2 |
|
| 2870 |
1.1 |
|
| 2871 |
1.1 2.2 |
|
| 2872 |
1.1 |
|
| 2873 |
1.1 |
|
| 2874 |
1.1 2.2 |
|
| 2875 |
1.1 2.2 |
|
| 2876 |
1.1 2.2 |
|
| 2877 |
1.1 2.2 |
|
| 2878 |
1.1 |
|
| 2880 |
1.1 |
|
| 2883 |
1.1 2.2 |
|
| 2884 |
1.1 2.2 |
|
| 2885 |
1.1 |
|
| 2886 |
1.1 |
|
| 2891 |
1.1 2.2 |
|
| 2892 |
1.1 |
|
| 2893 |
1.1 2.2 |
|
| 2894 |
1.1 2.2 |
|
| 2895 |
1.1 2.2 |
|
| 2896 |
1.1 |
|
| 2897 |
1.1 |
|
| 2898 |
1.1 2.2 |
|
| 2899 |
1.1 |
|
| 2900 |
1.1 2.2 |
|
| 2901 |
1.1 2.2 |
|
| 2902 |
1.1 2.2 |
|
| 2903 |
1.1 2.2 |
|
| 2904 |
1.1 |
|
| 2906 |
1.1 |
|
| 2909 |
1.1 2.2 |
|
| 2910 |
1.1 2.2 |
|
| 2911 |
1.1 |
|
| 2912 |
1.1 |
|
| 2917 |
1.1 |
|
| 2918 |
1.1 2.2 |
|
| 2919 |
1.1 2.2 |
|
| 2920 |
1.1 2.2 |
|
| 2921 |
1.1 2.2 |
|
| 2922 |
1.1 2.2 |
|
| 2925 |
1.1 2.2 |
|
| 2926 |
1.1 |
|
| 2927 |
1.1 2.2 |
|
| 2928 |
1.1 |
|
| 2929 |
1.1 |
|
| 2930 |
1.1 2.2 |
|
| 2931 |
1.1 2.2 |
|
| 2932 |
1.1 |
|
| 2933 |
1.1 |
|
| 2934 |
1.1 |
|
| 2936 |
1.1 |
|
| 2937 |
1.1 |
|
| 2938 |
1.1 2.2 |
|
| 2939 |
1.1 2.2 |
|
| 2940 |
1.1 |
|
| 2941 |
1.1 |
|
| 2942 |
1.1 |
|
| 2945 |
1.1 2.2 3.3 4.4 |
|
| 2946 |
1.1 2.2 3.3 |
|
| 2951 |
1.1 |
|
| 2952 |
1.1 2.2 |
|
| 2953 |
1.1 |
|
| 2954 |
1.1 2.2 |
|
| 2955 |
1.1 2.2 |
|
| 2956 |
1.1 |
|
| 2957 |
1.1 2.2 |
|
| 2958 |
1.1 2.2 |
|
| 2959 |
1.1 |
|
| 2960 |
1.1 |
|
| 2961 |
1.1 |
|
| 2963 |
1.1 |
|
| 2964 |
1.1 |
|
| 2965 |
1.1 |
|
| 2966 |
1.1 |
|
| 2967 |
1.1 |
|
| 2970 |
1.1 2.2 3.3 4.4 |
|
| 2971 |
1.1 2.2 3.3 |
|
| 2987 |
1.1 |
|
| 2993 |
1.1 |
|
| 2995 |
1.1 |
|
| 2999 |
1.1 2.2 3.3 |
|
| 3000 |
1.1 |
|
| 3001 |
1.1 |
|
| 3002 |
1.1 |
|
| 3003 |
1.1 |
|
| 3004 |
1.1 |
|
| 3007 |
1.1 |
|
| 3008 |
1.1 |
|
| 3010 |
1.1 |
|
| 3012 |
1.1 |
|
| 3015 |
1.1 |
|
| 3016 |
1.1 |
|
| 3018 |
1.1 |
|
| 3020 |
1.1 |
|
| 3023 |
1.1 |
|
| 3024 |
1.1 |
|
| 3026 |
1.1 |
|
| 3028 |
1.1 |
|
| 3031 |
1.1 |
|
| 3032 |
1.1 |
|
| 3034 |
1.1 |
|
| 3036 |
1.1 |
|
| 3039 |
1.1 |
|
| 3040 |
1.1 |
|
| 3042 |
1.1 |
|
| 3044 |
1.1 |
|
| 3045 |
1.1 |
|
| 3049 |
1.1 2.2 3.3 |
|
| 3051 |
1.1 |
|
| 3053 |
1.1 |
|
| 3066 |
1.1 |
|
| 3067 |
1.1 2.2 |
|
| 3068 |
1.1 2.2 |
|
| 3069 |
1.1 |
|
| 3070 |
1.1 2.2 |
|
| 3071 |
1.1 |
|
| 3073 |
1.1 |
|
| 3075 |
1.1 |
|
| 3077 |
1.1 |
|
| 3078 |
1.1 |
|
| 3079 |
1.1 |
|
| 3080 |
1.1 2.2 |
|
| 3081 |
1.1 |
|
| 3082 |
1.1 2.2 |
|
| 3085 |
1.1 2.2 |
|
| 3086 |
1.1 2.2 3.3 |
|
| 3087 |
1.1 |
|
| 3088 |
1.1 2.2 3.3 |
|
| 3089 |
1.1 |
|
| 3091 |
1.1 |
|
| 3093 |
1.1 |
|
| 3095 |
1.1 |
|
| 3097 |
1.1 2.2 |
|
| 3099 |
1.1 |
|
| 3100 |
1.1 |
|
| 3102 |
1.1 2.2 |
|
| 3103 |
1.1 |
|
| 3104 |
1.1 |
|
| 3105 |
1.1 2.2 |
|
| 3106 |
1.1 2.2 3.3 |
|
| 3107 |
1.1 2.2 3.3 4.4 |
|
| 3124 |
1.1 |
|
| 3126 |
1.1 |
|
| 3128 |
1.1 |
|
| 3129 |
1.1 2.2 |
|
| 3130 |
1.1 2.2 3.3 4.4 |
|
| 3131 |
1.1 |
|
| 3132 |
1.1 |
|
| 3134 |
1.1 |
|
| 3136 |
1.1 |
|
| 3138 |
1.1 |
|
| 3140 |
1.1 |
|
| 3141 |
1.1 2.2 |
|
| 3142 |
1.1 |
|
| 3143 |
1.1 2.2 |
|
| 3144 |
1.1 2.2 3.3 |
|
| 3145 |
1.1 2.2 3.3 |
|
| 3147 |
1.1 2.2 3.3 |
|
| 3148 |
1.1 |
|
| 3149 |
1.1 |
|
| 3150 |
1.1 |
|
| 3151 |
1.1 2.2 |
|
| 3152 |
1.1 |
|
| 3153 |
1.1 2.2 |
|
| 3154 |
1.1 |
|
| 3155 |
1.1 2.2 |
|
| 3158 |
1.1 2.2 |
|
| 3159 |
1.1 2.2 3.3 4.4 |
|
| 3160 |
1.1 2.2 3.3 |
|
| 3161 |
1.1 2.2 3.3 |
|
| 3162 |
1.1 |
|
| 3163 |
1.1 |
|
| 3164 |
1.1 |
|
| 3166 |
1.1 |
|
| 3168 |
1.1 |
|
| 3170 |
1.1 |
|
| 3172 |
1.1 |
|
| 3173 |
1.1 2.2 |
|
| 3174 |
1.1 |
|
| 3175 |
1.1 2.2 |
|
| 3176 |
1.1 2.2 3.3 |
|
| 3177 |
1.1 2.2 3.3 |
|
| 3178 |
1.1 |
|
| 3179 |
1.1 |
|
| 3180 |
1.1 |
|
| 3181 |
1.1 |
|
| 3183 |
1.1 |
|
| 3184 |
1.1 |
|
| 3186 |
1.1 2.2 |
|
| 3188 |
1.1 2.2 |
|
| 3190 |
1.1 |
|
| 3191 |
1.1 |
|
| 3192 |
1.1 |
|
| 3193 |
1.1 |
|
| 3194 |
1.1 2.2 |
|
| 3195 |
1.1 2.2 3.3 |
|
| 3196 |
1.1 2.2 3.3 4.4 |
|
| 3197 |
1.1 2.2 3.3 |
|
| 3198 |
1.1 2.2 3.3 4.4 |
|
| 3212 |
1.1 |
|
| 3213 |
1.1 |
|
| 3215 |
1.1 |
|
| 3216 |
1.1 |
|
| 3217 |
1.1 2.2 |
|
| 3218 |
1.1 |
|
| 3219 |
1.1 2.2 3.3 |
|
| 3220 |
1.1 |
|
| 3221 |
1.1 |
|
| 3222 |
1.1 |
|
| 3224 |
1.1 |
|
| 3226 |
1.1 |
|
| 3228 |
1.1 |
|
| 3230 |
1.1 |
|
| 3233 |
1.1 |
|
| 3234 |
1.1 |
|
| 3235 |
1.1 |
|
| 3236 |
1.1 |
|
| 3237 |
1.1 |
|
| 3238 |
1.1 |
|
| 3239 |
1.1 |
|
| 3240 |
1.1 |
|
| 3242 |
1.1 |
|
| 3243 |
1.1 |
|
| 3244 |
1.1 |
|
| 3245 |
1.1 |
|
| 3246 |
1.1 |
|
| 3247 |
1.1 2.2 |
|
| 3248 |
1.1 2.2 |
|
| 3249 |
1.1 2.2 3.3 |
|
| 3250 |
1.1 |
|
| 3251 |
1.1 2.2 |
|
| 3252 |
1.1 2.2 |
|
| 3253 |
1.1 2.2 3.3 |
|
| 3256 |
1.1 2.2 |
|
| 3257 |
1.1 |
|
| 3258 |
1.1 2.2 3.3 |
|
| 3259 |
1.1 2.2 3.3 |
|
| 3260 |
1.1 |
|
| 3261 |
1.1 |
|
| 3262 |
1.1 |
|
| 3263 |
1.1 |
|
| 3264 |
1.1 |
|
| 3266 |
1.1 |
|
| 3268 |
1.1 |
|
| 3270 |
1.1 |
|
| 3273 |
1.1 |
|
| 3274 |
1.1 |
|
| 3275 |
1.1 |
|
| 3276 |
1.1 |
|
| 3277 |
1.1 |
|
| 3278 |
1.1 |
|
| 3279 |
1.1 |
|
| 3280 |
1.1 |
|
| 3281 |
1.1 |
|
| 3282 |
1.1 |
|
| 3283 |
1.1 2.2 |
|
| 3284 |
1.1 2.2 |
|
| 3285 |
1.1 2.2 |
|
| 3286 |
1.1 2.2 |
|
| 3288 |
1.1 |
|
| 3289 |
1.1 |
|
| 3290 |
1.1 |
|
| 3292 |
1.1 2.2 |
|
| 3294 |
1.1 2.2 |
|
| 3296 |
1.1 2.2 |
|
| 3298 |
1.1 2.2 |
|
| 3299 |
1.1 |
|
| 3300 |
1.1 |
|
| 3301 |
1.1 |
|
| 3302 |
1.1 |
|
| 3303 |
1.1 2.2 |
|
| 3304 |
1.1 2.2 3.3 |
|
| 3305 |
1.1 2.2 3.3 4.4 |
|
| 3306 |
1.1 2.2 3.3 |
|
| 3307 |
1.1 2.2 3.3 4.4 |
|
| 3308 |
1.1 2.2 3.3 |
|
| 3309 |
1.1 2.2 3.3 4.4 |
|
| 3330 |
1.1 |
|
| 3331 |
1.1 |
|
| 3332 |
1.1 |
|
| 3334 |
1.1 |
|
| 3336 |
1.1 |
|
| 3337 |
1.1 2.2 |
|
| 3338 |
1.1 2.2 3.3 4.4 5.5 |
|
| 3339 |
1.1 |
|
| 3340 |
1.1 |
|
| 3341 |
1.1 |
|
| 3342 |
1.1 |
|
| 3344 |
1.1 |
|
| 3346 |
1.1 |
|
| 3348 |
1.1 |
|
| 3350 |
1.1 |
|
| 3352 |
1.1 |
|
| 3355 |
1.1 |
|
| 3356 |
1.1 |
|
| 3357 |
1.1 |
|
| 3358 |
1.1 |
|
| 3359 |
1.1 |
|
| 3360 |
1.1 |
|
| 3361 |
1.1 |
|
| 3362 |
1.1 |
|
| 3363 |
1.1 2.2 3.3 4.4 |
|
| 3364 |
1.1 2.2 3.3 4.4 |
|
| 3365 |
1.1 2.2 3.3 4.4 |
|
| 3366 |
1.1 2.2 3.3 4.4 |
|
| 3367 |
1.1 2.2 3.3 4.4 |
|
| 3368 |
1.1 2.2 3.3 4.4 |
|
| 3369 |
1.1 2.2 3.3 4.4 |
|
| 3370 |
1.1 2.2 3.3 4.4 |
|
| 3372 |
1.1 2.2 3.3 |
|
| 3373 |
1.1 |
|
| 3374 |
1.1 |
|
| 3375 |
1.1 |
|
| 3376 |
1.1 |
|
| 3377 |
1.1 2.2 |
|
| 3378 |
1.1 2.2 3.3 |
|
| 3379 |
1.1 |
|
| 3380 |
1.1 2.2 |
|
| 3381 |
1.1 |
|
| 3382 |
1.1 2.2 |
|
| 3383 |
1.1 |
|
| 3384 |
1.1 2.2 |
|
| 3385 |
1.1 |
|
| 3386 |
1.1 2.2 |
|
| 3389 |
1.1 2.2 |
|
| 3390 |
1.1 2.2 3.3 4.4 5.5 |
|
| 3391 |
1.1 2.2 3.3 |
|
| 3392 |
1.1 2.2 3.3 |
|
| 3393 |
1.1 |
|
| 3394 |
1.1 |
|
| 3395 |
1.1 |
|
| 3396 |
1.1 |
|
| 3397 |
1.1 |
|
| 3398 |
1.1 |
|
| 3400 |
1.1 |
|
| 3402 |
1.1 |
|
| 3404 |
1.1 |
|
| 3406 |
1.1 |
|
| 3409 |
1.1 |
|
| 3410 |
1.1 |
|
| 3411 |
1.1 |
|
| 3412 |
1.1 |
|
| 3413 |
1.1 |
|
| 3414 |
1.1 |
|
| 3415 |
1.1 |
|
| 3416 |
1.1 |
|
| 3417 |
1.1 2.2 3.3 4.4 |
|
| 3418 |
1.1 2.2 3.3 4.4 |
|
| 3419 |
1.1 2.2 3.3 4.4 |
|
| 3420 |
1.1 2.2 3.3 4.4 |
|
| 3421 |
1.1 2.2 3.3 4.4 |
|
| 3422 |
1.1 2.2 3.3 4.4 |
|
| 3423 |
1.1 2.2 3.3 4.4 |
|
| 3424 |
1.1 2.2 3.3 4.4 |
|
| 3425 |
1.1 |
|
| 3426 |
1.1 |
|
| 3427 |
1.1 |
|
| 3428 |
1.1 |
|
| 3429 |
1.1 |
|
| 3430 |
1.1 |
|
| 3431 |
1.1 |
|
| 3432 |
1.1 |
|
| 3434 |
1.1 |
|
| 3435 |
1.1 |
|
| 3436 |
1.1 |
|
| 3437 |
1.1 |
|
| 3439 |
1.1 2.2 |
|
| 3441 |
1.1 2.2 |
|
| 3443 |
1.1 2.2 |
|
| 3445 |
1.1 2.2 |
|
| 3447 |
1.1 |
|
| 3448 |
1.1 |
|
| 3449 |
1.1 |
|
| 3450 |
1.1 |
|
| 3451 |
1.1 |
|
| 3452 |
1.1 2.2 |
|
| 3453 |
1.1 2.2 3.3 |
|
| 3454 |
1.1 2.2 3.3 |
|
| 3455 |
1.1 2.2 3.3 4.4 |
|
| 3456 |
1.1 2.2 3.3 |
|
| 3457 |
1.1 2.2 3.3 4.4 |
|
| 3458 |
1.1 2.2 3.3 |
|
| 3459 |
1.1 2.2 3.3 4.4 |
|
| 3460 |
1.1 2.2 3.3 |
|
| 3461 |
1.1 2.2 3.3 4.4 |
|
| 3477 |
1.1 |
|
| 3478 |
1.1 2.2 |
|
| 3479 |
1.1 |
|
| 3480 |
1.1 2.2 |
|
| 3481 |
1.1 2.2 |
|
| 3482 |
1.1 |
|
| 3483 |
1.1 |
|
| 3484 |
1.1 |
|
| 3485 |
1.1 2.2 |
|
| 3486 |
1.1 |
|
| 3487 |
1.1 2.2 |
|
| 3488 |
1.1 2.2 |
|
| 3489 |
1.1 |
|
| 3490 |
1.1 2.2 |
|
| 3491 |
1.1 |
|
| 3492 |
1.1 2.2 3.3 |
|
| 3493 |
1.1 2.2 3.3 |
|
| 3494 |
1.1 2.2 |
|
| 3495 |
1.1 2.2 |
|
| 3499 |
1.1 2.2 |
|
| 3500 |
1.1 |
|
| 3501 |
1.1 |
|
| 3502 |
1.1 2.2 |
|
| 3503 |
1.1 2.2 3.3 4.4 |
|
| 3507 |
1.1 2.2 |
|
| 3508 |
1.1 |
|
| 3509 |
1.1 2.2 |
|
| 3510 |
1.1 2.2 |
|
| 3511 |
1.1 |
|
| 3512 |
1.1 |
|
| 3513 |
1.1 2.2 |
|
| 3514 |
1.1 2.2 |
|
| 3515 |
1.1 |
|
| 3516 |
1.1 |
|
| 3517 |
1.1 |
|
| 3518 |
1.1 |
|
| 3519 |
1.1 2.2 |
|
| 3520 |
1.1 2.2 |
|
| 3521 |
1.1 2.2 3.3 |
|
| 3522 |
1.1 2.2 3.3 |
|
| 3526 |
1.1 2.2 |
|
| 3527 |
1.1 2.2 |
|
| 3528 |
1.1 |
|
| 3529 |
1.1 2.2 3.3 4.4 5.5 |
|
| 3534 |
1.1 |
|
| 3536 |
1.1 2.2 |
|
| 3537 |
1.1 2.2 |
|
| 3538 |
1.1 |
|
| 3539 |
1.1 |
|
| 3540 |
1.1 |
|
| 3541 |
1.1 |
|
| 3542 |
1.1 |
|
| 3543 |
1.1 |
|
| 3544 |
1.1 2.2 |
|
| 3545 |
1.1 2.2 |
|
| 3546 |
1.1 |
|
| 3547 |
1.1 |
|
| 3548 |
1.1 2.2 3.3 4.4 |
|
| 3549 |
1.1 2.2 3.3 |
|
| 3552 |
1.1 |
|
| 3553 |
1.1 2.2 |
|
| 3554 |
1.1 |
|
| 3555 |
1.1 |
|
| 3556 |
1.1 2.2 |
|
| 3557 |
1.1 |
|
| 3558 |
1.1 |
|
| 3559 |
1.1 |
|
| 3560 |
1.1 2.2 |
|
| 3561 |
1.1 |
|
| 3562 |
1.1 |
|
| 3563 |
1.1 2.2 |
|
| 3564 |
1.1 |
|
| 3565 |
1.1 |
|
| 3566 |
1.1 2.2 3.3 4.4 |
|
| 3567 |
1.1 2.2 3.3 4.4 |
|
| 3571 |
1.1 2.2 |
|
| 3572 |
1.1 |
|
| 3573 |
1.1 2.2 |
|
| 3574 |
1.1 |
|
| 3575 |
1.1 2.2 |
|
| 3578 |
1.1 2.2 |
|
| 3579 |
1.1 |
|
| 3580 |
1.1 |
|
| 3581 |
1.1 |
|
| 3582 |
1.1 2.2 |
|
| 3583 |
1.1 |
|
| 3584 |
1.1 |
|
| 3585 |
1.1 |
|
| 3586 |
1.1 |
|
| 3587 |
1.1 |
|
| 3589 |
1.1 |
|
| 3592 |
1.1 |
|
| 3593 |
1.1 |
|
| 3594 |
1.1 2.2 |
|
| 3595 |
1.1 2.2 |
|
| 3596 |
1.1 |
|
| 3597 |
1.1 |
|
| 3601 |
1.1 |
|
| 3604 |
1.1 |
|
| 3605 |
1.1 |
|
| 3606 |
1.1 2.2 |
|
| 3607 |
1.1 |
|
| 3608 |
1.1 2.2 |
|
| 3609 |
1.1 |
|
| 3610 |
1.1 2.2 |
|
| 3611 |
1.1 2.2 |
|
| 3613 |
1.1 2.2 |
|
| 3616 |
1.1 2.2 |
|
| 3618 |
1.1 2.2 |
|
| 3619 |
1.1 |
|
| 3620 |
1.1 2.2 |
|
| 3621 |
1.1 2.2 |
|
| 3622 |
1.1 |
|
| 3623 |
1.1 2.2 |
|
| 3624 |
1.1 |
|
| 3625 |
1.1 |
|
| 3626 |
1.1 |
|
| 3627 |
1.1 |
|
| 3628 |
1.1 2.2 |
|
| 3629 |
1.1 2.2 |
|
| 3630 |
1.1 |
|
| 3631 |
1.1 |
|
| 3632 |
1.1 |
|
| 3634 |
1.1 2.2 3.3 4.4 |
|
| 3635 |
1.1 2.2 3.3 |
|
| 3640 |
1.1 |
|
| 3641 |
1.1 2.2 |
|
| 3642 |
1.1 |
|
| 3643 |
1.1 2.2 |
|
| 3644 |
1.1 2.2 |
|
| 3646 |
1.1 2.2 |
|
| 3647 |
1.1 2.2 |
|
| 3648 |
1.1 |
|
| 3649 |
1.1 2.2 |
|
| 3650 |
1.1 |
|
| 3651 |
1.1 |
|
| 3652 |
1.1 2.2 |
|
| 3653 |
1.1 2.2 |
|
| 3654 |
1.1 |
|
| 3656 |
1.1 2.2 3.3 4.4 |
|
| 3657 |
1.1 2.2 3.3 |
|
| 3665 |
1.1 2.2 |
|
| 3666 |
1.1 2.2 |
|
| 3667 |
1.1 2.2 3.3 |
|
| 3668 |
1.1 2.2 |
|
| 3669 |
1.1 |
|
| 3670 |
1.1 2.2 |
|
| 3671 |
1.1 |
|
| 3673 |
1.1 |
|
| 3675 |
1.1 |
|
| 3676 |
1.1 |
|
| 3677 |
1.1 2.2 |
|
| 3678 |
1.1 |
|
| 3680 |
1.1 |
|
| 3681 |
1.1 |
|
| 3683 |
1.1 |
|
| 3684 |
1.1 |
|
| 3685 |
1.1 |
|
| 3686 |
1.1 |
|
| 3691 |
1.1 2.2 |
|
| 3692 |
1.1 2.2 |
|
| 3693 |
1.1 2.2 3.3 |
|
| 3694 |
1.1 2.2 |
|
| 3695 |
1.1 |
|
| 3696 |
1.1 2.2 |
|
| 3697 |
1.1 |
|
| 3699 |
1.1 |
|
| 3701 |
1.1 |
|
| 3702 |
1.1 |
|
| 3703 |
1.1 2.2 |
|
| 3704 |
1.1 |
|
| 3706 |
1.1 |
|
| 3707 |
1.1 |
|
| 3709 |
1.1 |
|
| 3710 |
1.1 |
|
| 3711 |
1.1 |
|
| 3712 |
1.1 |
|
| 3722 |
1.1 2.2 3.3 4.4 |
|
| 3723 |
1.1 |
|
| 3725 |
1.1 |
|
| 3726 |
1.1 |
|
| 3727 |
1.1 |
|
| 3728 |
1.1 2.2 |
|
| 3729 |
1.1 |
|
| 3730 |
1.1 2.2 |
|
| 3731 |
1.1 2.2 3.3 4.4 |
|
| 3732 |
1.1 2.2 3.3 |
|
| 3733 |
1.1 |
|
| 3734 |
1.1 |
|
| 3736 |
1.1 |
|
| 3738 |
1.1 |
|
| 3740 |
1.1 |
|
| 3742 |
1.1 |
|
| 3743 |
1.1 |
|
| 3744 |
1.1 2.2 |
|
| 3745 |
1.1 |
|
| 3746 |
1.1 |
|
| 3748 |
1.1 |
|
| 3750 |
1.1 |
|
| 3752 |
1.1 |
|
| 3754 |
1.1 |
|
| 3755 |
1.1 |
|
| 3756 |
1.1 |
|
| 3757 |
1.1 |
|
| 3758 |
1.1 |
|
| 3760 |
1.1 |
|
| 3762 |
1.1 |
|
| 3764 |
1.1 |
|
| 3766 |
1.1 |
|
| 3767 |
1.1 |
|
| 3768 |
1.1 2.2 |
|
| 3769 |
1.1 |
|
| 3770 |
1.1 |
|
| 3772 |
1.1 |
|
| 3774 |
1.1 |
|
| 3776 |
1.1 |
|
| 3778 |
1.1 |
|
| 3779 |
1.1 |
|
| 3780 |
1.1 |
|
| 3781 |
1.1 |
|
| 3782 |
1.1 |
|
| 3784 |
1.1 |
|
| 3786 |
1.1 |
|
| 3788 |
1.1 |
|
| 3790 |
1.1 |
|
| 3791 |
1.1 |
|
| 3792 |
1.1 2.2 |
|
| 3793 |
1.1 |
|
| 3794 |
1.1 |
|
| 3796 |
1.1 |
|
| 3798 |
1.1 |
|
| 3800 |
1.1 |
|
| 3802 |
1.1 |
|
| 3803 |
1.1 |
|
| 3804 |
1.1 |
|
| 3805 |
1.1 |
|
| 3806 |
1.1 |
|
| 3808 |
1.1 |
|
| 3810 |
1.1 |
|
| 3812 |
1.1 |
|
| 3814 |
1.1 |
|
| 3815 |
1.1 |
|
| 3816 |
1.1 2.2 |
|
| 3817 |
1.1 |
|
| 3818 |
1.1 |
|
| 3820 |
1.1 |
|
| 3822 |
1.1 |
|
| 3824 |
1.1 |
|
| 3826 |
1.1 |
|
| 3827 |
1.1 |
|
| 3828 |
1.1 |
|
| 3829 |
1.1 |
|
| 3830 |
1.1 |
|
| 3832 |
1.1 |
|
| 3834 |
1.1 |
|
| 3836 |
1.1 |
|
| 3838 |
1.1 |
|
| 3839 |
1.1 |
|
| 3840 |
1.1 2.2 |
|
| 3841 |
1.1 |
|
| 3842 |
1.1 |
|
| 3844 |
1.1 |
|
| 3846 |
1.1 |
|
| 3848 |
1.1 |
|
| 3850 |
1.1 |
|
| 3851 |
1.1 |
|
| 3852 |
1.1 |
|
| 3853 |
1.1 |
|
| 3854 |
1.1 |
|
| 3856 |
1.1 |
|
| 3858 |
1.1 |
|
| 3860 |
1.1 |
|
| 3862 |
1.1 |
|
| 3863 |
1.1 |
|
| 3864 |
1.1 2.2 |
|
| 3865 |
1.1 |
|
| 3866 |
1.1 |
|
| 3868 |
1.1 |
|
| 3870 |
1.1 |
|
| 3872 |
1.1 |
|
| 3874 |
1.1 |
|
| 3875 |
1.1 |
|
| 3876 |
1.1 |
|
| 3877 |
1.1 |
|
| 3878 |
1.1 |
|
| 3880 |
1.1 |
|
| 3882 |
1.1 |
|
| 3884 |
1.1 |
|
| 3886 |
1.1 |
|
| 3887 |
1.1 |
|
| 3888 |
1.1 2.2 |
|
| 3889 |
1.1 |
|
| 3890 |
1.1 |
|
| 3892 |
1.1 |
|
| 3894 |
1.1 |
|
| 3896 |
1.1 |
|
| 3898 |
1.1 |
|
| 3899 |
1.1 |
|
| 3900 |
1.1 |
|
| 3901 |
1.1 |
|
| 3902 |
1.1 |
|
| 3904 |
1.1 |
|
| 3906 |
1.1 |
|
| 3908 |
1.1 |
|
| 3910 |
1.1 |
|
| 3911 |
1.1 |
|
| 3912 |
1.1 2.2 |
|
| 3913 |
1.1 |
|
| 3914 |
1.1 |
|
| 3916 |
1.1 |
|
| 3918 |
1.1 |
|
| 3920 |
1.1 |
|
| 3922 |
1.1 |
|
| 3924 |
1.1 2.2 3.3 |
|
| 3925 |
1.1 |
|
| 3926 |
1.1 |
|
| 3927 |
1.1 |
|
| 3928 |
1.1 |
|
| 3930 |
1.1 |
|
| 3932 |
1.1 |
|
| 3934 |
1.1 |
|
| 3936 |
1.1 |
|
| 3937 |
1.1 |
|
| 3938 |
1.1 2.2 |
|
| 3939 |
1.1 |
|
| 3940 |
1.1 |
|
| 3942 |
1.1 |
|
| 3944 |
1.1 |
|
| 3946 |
1.1 |
|
| 3948 |
1.1 |
|
| 3949 |
1.1 |
|
| 3950 |
1.1 |
|
| 3951 |
1.1 |
|
| 3952 |
1.1 |
|
| 3954 |
1.1 |
|
| 3956 |
1.1 |
|
| 3958 |
1.1 |
|
| 3960 |
1.1 |
|
| 3961 |
1.1 |
|
| 3962 |
1.1 |
|
| 3963 |
1.1 |
|
| 3964 |
1.1 |
|
| 3966 |
1.1 |
|
| 3968 |
1.1 |
|
| 3970 |
1.1 |
|
| 3972 |
1.1 |
|
| 3973 |
1.1 2.2 |
|
| 3974 |
1.1 2.2 |
|
| 3975 |
1.1 |
|
| 3976 |
1.1 |
|
| 3978 |
1.1 |
|
| 3980 |
1.1 |
|
| 3982 |
1.1 |
|
| 3984 |
1.1 |
|
| 3985 |
1.1 2.2 |
|
| 3986 |
1.1 2.2 3.3 |
|
| 3987 |
1.1 |
|
| 3988 |
1.1 |
|
| 3990 |
1.1 |
|
| 3992 |
1.1 |
|
| 3994 |
1.1 |
|
| 3996 |
1.1 |
|
| 3999 |
1.1 2.2 |
|
| 4000 |
1.1 |
|
| 4001 |
1.1 2.2 |
|
| 4002 |
1.1 2.2 3.3 |
|
| 4003 |
1.1 2.2 |
|
| 4004 |
1.1 |
|
| 4005 |
1.1 |
|
| 4007 |
1.1 |
|
| 4009 |
1.1 |
|
| 4011 |
1.1 |
|
| 4013 |
1.1 |
|
| 4014 |
1.1 |
|
| 4015 |
1.1 |
|
| 4016 |
1.1 |
|
| 4017 |
1.1 |
|
| 4019 |
1.1 |
|
| 4021 |
1.1 |
|
| 4023 |
1.1 |
|
| 4025 |
1.1 |
|
| 4026 |
1.1 |
|
| 4027 |
1.1 |
|
| 4028 |
1.1 |
|
| 4029 |
1.1 |
|
| 4031 |
1.1 |
|
| 4033 |
1.1 |
|
| 4035 |
1.1 |
|
| 4037 |
1.1 |
|
| 4038 |
1.1 |
|
| 4039 |
1.1 |
|
| 4040 |
1.1 |
|
| 4041 |
1.1 |
|
| 4043 |
1.1 |
|
| 4045 |
1.1 |
|
| 4047 |
1.1 |
|
| 4049 |
1.1 |
|
| 4050 |
1.1 |
|
| 4051 |
1.1 |
|
| 4052 |
1.1 |
|
| 4053 |
1.1 |
|
| 4055 |
1.1 |
|
| 4057 |
1.1 |
|
| 4059 |
1.1 |
|
| 4061 |
1.1 |
|
| 4062 |
1.1 |
|
| 4063 |
1.1 |
|
| 4064 |
1.1 |
|
| 4065 |
1.1 |
|
| 4067 |
1.1 |
|
| 4069 |
1.1 |
|
| 4071 |
1.1 |
|
| 4073 |
1.1 |
|
| 4074 |
1.1 |
|
| 4075 |
1.1 |
|
| 4076 |
1.1 |
|
| 4077 |
1.1 |
|
| 4079 |
1.1 |
|
| 4081 |
1.1 |
|
| 4083 |
1.1 |
|
| 4085 |
1.1 |
|
| 4086 |
1.1 |
|
| 4087 |
1.1 |
|
| 4088 |
1.1 |
|
| 4089 |
1.1 |
|
| 4091 |
1.1 |
|
| 4093 |
1.1 |
|
| 4095 |
1.1 |
|
| 4097 |
1.1 |
|
| 4099 |
1.1 2.2 |
|
| 4100 |
1.1 |
|
| 4101 |
1.1 |
|
| 4102 |
1.1 |
|
| 4103 |
1.1 |
|
| 4105 |
1.1 |
|
| 4107 |
1.1 |
|
| 4109 |
1.1 |
|
| 4111 |
1.1 |
|
| 4112 |
1.1 |
|
| 4113 |
1.1 |
|
| 4114 |
1.1 |
|
| 4115 |
1.1 |
|
| 4117 |
1.1 |
|
| 4119 |
1.1 |
|
| 4121 |
1.1 |
|
| 4123 |
1.1 |
|
| 4134 |
1.1 2.2 3.3 4.4 |
|
| 4135 |
1.1 |
|
| 4137 |
1.1 |
|
| 4138 |
1.1 |
|
| 4139 |
1.1 |
|
| 4140 |
1.1 2.2 |
|
| 4141 |
1.1 |
|
| 4142 |
1.1 2.2 |
|
| 4143 |
1.1 2.2 3.3 4.4 |
|
| 4144 |
1.1 2.2 3.3 |
|
| 4145 |
1.1 |
|
| 4146 |
1.1 |
|
| 4148 |
1.1 2.2 |
|
| 4150 |
1.1 2.2 |
|
| 4152 |
1.1 |
|
| 4154 |
1.1 |
|
| 4155 |
1.1 |
|
| 4156 |
1.1 2.2 |
|
| 4157 |
1.1 |
|
| 4158 |
1.1 |
|
| 4160 |
1.1 2.2 |
|
| 4162 |
1.1 2.2 |
|
| 4164 |
1.1 |
|
| 4166 |
1.1 |
|
| 4167 |
1.1 |
|
| 4168 |
1.1 |
|
| 4169 |
1.1 |
|
| 4170 |
1.1 |
|
| 4172 |
1.1 2.2 |
|
| 4174 |
1.1 2.2 |
|
| 4176 |
1.1 |
|
| 4178 |
1.1 |
|
| 4179 |
1.1 |
|
| 4180 |
1.1 2.2 |
|
| 4181 |
1.1 |
|
| 4182 |
1.1 |
|
| 4184 |
1.1 2.2 |
|
| 4186 |
1.1 2.2 |
|
| 4188 |
1.1 |
|
| 4190 |
1.1 |
|
| 4191 |
1.1 |
|
| 4192 |
1.1 |
|
| 4193 |
1.1 |
|
| 4194 |
1.1 |
|
| 4196 |
1.1 2.2 |
|
| 4198 |
1.1 2.2 |
|
| 4200 |
1.1 |
|
| 4202 |
1.1 |
|
| 4203 |
1.1 |
|
| 4204 |
1.1 2.2 |
|
| 4205 |
1.1 |
|
| 4206 |
1.1 |
|
| 4208 |
1.1 2.2 |
|
| 4210 |
1.1 2.2 |
|
| 4212 |
1.1 |
|
| 4214 |
1.1 |
|
| 4215 |
1.1 |
|
| 4216 |
1.1 |
|
| 4217 |
1.1 |
|
| 4218 |
1.1 |
|
| 4220 |
1.1 2.2 |
|
| 4222 |
1.1 2.2 |
|
| 4224 |
1.1 |
|
| 4226 |
1.1 |
|
| 4227 |
1.1 |
|
| 4228 |
1.1 2.2 |
|
| 4229 |
1.1 |
|
| 4230 |
1.1 |
|
| 4232 |
1.1 2.2 |
|
| 4234 |
1.1 2.2 |
|
| 4236 |
1.1 |
|
| 4238 |
1.1 |
|
| 4239 |
1.1 |
|
| 4240 |
1.1 |
|
| 4241 |
1.1 |
|
| 4242 |
1.1 |
|
| 4244 |
1.1 2.2 |
|
| 4246 |
1.1 2.2 |
|
| 4248 |
1.1 |
|
| 4250 |
1.1 |
|
| 4251 |
1.1 |
|
| 4252 |
1.1 2.2 |
|
| 4253 |
1.1 |
|
| 4254 |
1.1 |
|
| 4256 |
1.1 2.2 |
|
| 4258 |
1.1 2.2 |
|
| 4260 |
1.1 |
|
| 4262 |
1.1 |
|
| 4263 |
1.1 |
|
| 4264 |
1.1 |
|
| 4265 |
1.1 |
|
| 4266 |
1.1 |
|
| 4268 |
1.1 2.2 |
|
| 4270 |
1.1 2.2 |
|
| 4272 |
1.1 |
|
| 4274 |
1.1 |
|
| 4275 |
1.1 |
|
| 4276 |
1.1 2.2 |
|
| 4277 |
1.1 |
|
| 4278 |
1.1 |
|
| 4280 |
1.1 2.2 |
|
| 4282 |
1.1 2.2 |
|
| 4284 |
1.1 |
|
| 4286 |
1.1 |
|
| 4287 |
1.1 |
|
| 4288 |
1.1 |
|
| 4289 |
1.1 |
|
| 4290 |
1.1 |
|
| 4292 |
1.1 2.2 |
|
| 4294 |
1.1 2.2 |
|
| 4296 |
1.1 |
|
| 4298 |
1.1 |
|
| 4299 |
1.1 |
|
| 4300 |
1.1 2.2 |
|
| 4301 |
1.1 |
|
| 4302 |
1.1 |
|
| 4304 |
1.1 2.2 |
|
| 4306 |
1.1 2.2 |
|
| 4308 |
1.1 |
|
| 4310 |
1.1 |
|
| 4311 |
1.1 |
|
| 4312 |
1.1 |
|
| 4313 |
1.1 |
|
| 4314 |
1.1 |
|
| 4316 |
1.1 2.2 |
|
| 4318 |
1.1 2.2 |
|
| 4320 |
1.1 |
|
| 4322 |
1.1 |
|
| 4323 |
1.1 |
|
| 4324 |
1.1 2.2 |
|
| 4325 |
1.1 |
|
| 4326 |
1.1 |
|
| 4328 |
1.1 2.2 |
|
| 4330 |
1.1 2.2 |
|
| 4332 |
1.1 |
|
| 4334 |
1.1 |
|
| 4336 |
1.1 2.2 3.3 |
|
| 4337 |
1.1 |
|
| 4338 |
1.1 |
|
| 4339 |
1.1 |
|
| 4340 |
1.1 |
|
| 4341 |
1.1 2.2 3.3 |
|
| 4343 |
1.1 2.2 |
|
| 4345 |
1.1 2.2 |
|
| 4347 |
1.1 |
|
| 4349 |
1.1 |
|
| 4350 |
1.1 2.2 3.3 |
|
| 4351 |
1.1 |
|
| 4352 |
1.1 2.2 |
|
| 4353 |
1.1 |
|
| 4354 |
1.1 |
|
| 4356 |
1.1 2.2 |
|
| 4358 |
1.1 2.2 |
|
| 4360 |
1.1 |
|
| 4362 |
1.1 |
|
| 4363 |
1.1 |
|
| 4364 |
1.1 |
|
| 4365 |
1.1 |
|
| 4366 |
1.1 |
|
| 4368 |
1.1 2.2 |
|
| 4370 |
1.1 2.2 |
|
| 4372 |
1.1 |
|
| 4374 |
1.1 |
|
| 4375 |
1.1 |
|
| 4376 |
1.1 |
|
| 4377 |
1.1 |
|
| 4378 |
1.1 |
|
| 4380 |
1.1 2.2 |
|
| 4382 |
1.1 2.2 |
|
| 4384 |
1.1 |
|
| 4386 |
1.1 |
|
| 4387 |
1.1 2.2 |
|
| 4388 |
1.1 2.2 |
|
| 4389 |
1.1 |
|
| 4390 |
1.1 |
|
| 4392 |
1.1 2.2 |
|
| 4394 |
1.1 2.2 |
|
| 4396 |
1.1 |
|
| 4398 |
1.1 |
|
| 4399 |
1.1 2.2 |
|
| 4400 |
1.1 2.2 3.3 |
|
| 4401 |
1.1 |
|
| 4402 |
1.1 |
|
| 4403 |
1.1 2.2 3.3 |
|
| 4405 |
1.1 2.2 |
|
| 4407 |
1.1 2.2 |
|
| 4409 |
1.1 |
|
| 4411 |
1.1 |
|
| 4412 |
1.1 2.2 3.3 |
|
| 4415 |
1.1 2.2 |
|
| 4416 |
1.1 |
|
| 4417 |
1.1 2.2 |
|
| 4418 |
1.1 2.2 3.3 |
|
| 4419 |
1.1 2.2 |
|
| 4420 |
1.1 |
|
| 4421 |
1.1 |
|
| 4423 |
1.1 2.2 |
|
| 4425 |
1.1 2.2 |
|
| 4427 |
1.1 |
|
| 4429 |
1.1 |
|
| 4430 |
1.1 |
|
| 4431 |
1.1 |
|
| 4432 |
1.1 |
|
| 4433 |
1.1 |
|
| 4435 |
1.1 2.2 |
|
| 4437 |
1.1 2.2 |
|
| 4439 |
1.1 |
|
| 4441 |
1.1 |
|
| 4442 |
1.1 |
|
| 4443 |
1.1 |
|
| 4444 |
1.1 |
|
| 4445 |
1.1 |
|
| 4447 |
1.1 2.2 |
|
| 4449 |
1.1 2.2 |
|
| 4451 |
1.1 |
|
| 4453 |
1.1 |
|
| 4454 |
1.1 |
|
| 4455 |
1.1 |
|
| 4456 |
1.1 |
|
| 4457 |
1.1 |
|
| 4459 |
1.1 2.2 |
|
| 4461 |
1.1 2.2 |
|
| 4463 |
1.1 |
|
| 4465 |
1.1 |
|
| 4466 |
1.1 |
|
| 4467 |
1.1 |
|
| 4468 |
1.1 |
|
| 4469 |
1.1 |
|
| 4471 |
1.1 2.2 |
|
| 4473 |
1.1 2.2 |
|
| 4475 |
1.1 |
|
| 4477 |
1.1 |
|
| 4478 |
1.1 |
|
| 4479 |
1.1 |
|
| 4480 |
1.1 |
|
| 4481 |
1.1 |
|
| 4483 |
1.1 2.2 |
|
| 4485 |
1.1 2.2 |
|
| 4487 |
1.1 |
|
| 4489 |
1.1 |
|
| 4490 |
1.1 |
|
| 4491 |
1.1 |
|
| 4492 |
1.1 |
|
| 4493 |
1.1 |
|
| 4495 |
1.1 2.2 |
|
| 4497 |
1.1 2.2 |
|
| 4499 |
1.1 |
|
| 4501 |
1.1 |
|
| 4502 |
1.1 |
|
| 4503 |
1.1 |
|
| 4504 |
1.1 |
|
| 4505 |
1.1 |
|
| 4507 |
1.1 2.2 |
|
| 4509 |
1.1 2.2 |
|
| 4511 |
1.1 |
|
| 4513 |
1.1 |
|
| 4515 |
1.1 2.2 |
|
| 4516 |
1.1 |
|
| 4517 |
1.1 |
|
| 4518 |
1.1 |
|
| 4519 |
1.1 |
|
| 4520 |
1.1 2.2 3.3 |
|
| 4522 |
1.1 2.2 |
|
| 4524 |
1.1 2.2 |
|
| 4526 |
1.1 |
|
| 4528 |
1.1 |
|
| 4529 |
1.1 2.2 3.3 |
|
| 4530 |
1.1 |
|
| 4531 |
1.1 |
|
| 4532 |
1.1 |
|
| 4533 |
1.1 |
|
| 4534 |
1.1 2.2 3.3 |
|
| 4536 |
1.1 2.2 |
|
| 4538 |
1.1 2.2 |
|
| 4540 |
1.1 |
|
| 4542 |
1.1 |
|
| 4543 |
1.1 2.2 3.3 |
|
| 4551 |
1.1 |
|
| 4552 |
1.1 |
|
| 4553 |
1.1 |
|
| 4554 |
1.1 |
|
| 4555 |
1.1 |
|
| 4556 |
1.1 |
|
| 4557 |
1.1 |
|
| 4558 |
1.1 |
|
| 4559 |
1.1 |
|
| 4560 |
1.1 |
|
| 4561 |
1.1 |
|
| 4562 |
1.1 |
|
| 4563 |
1.1 |
|
| 4564 |
1.1 |
|
| 4565 |
1.1 |
|
| 4566 |
1.1 |
|
| 4567 |
1.1 |
|
| 4568 |
1.1 |
|
| 4569 |
1.1 |
|
| 4570 |
1.1 |
|
| 4571 |
1.1 |
|
| 4572 |
1.1 |
|
| 4573 |
1.1 |
|
| 4574 |
1.1 |
|
| 4575 |
1.1 |
|
| 4576 |
1.1 |
|
| 4577 |
1.1 |
|
| 4578 |
1.1 |
|
| 4579 |
1.1 |
|
| 4580 |
1.1 |
|
| 4581 |
1.1 |
|
| 4582 |
1.1 |
|
| 4583 |
1.1 |
|
| 4584 |
1.1 |
|
| 4585 |
1.1 |
|
| 4586 |
1.1 |
|
| 4587 |
1.1 |
|
| 4588 |
1.1 |
|
| 4589 |
1.1 |
|
| 4590 |
1.1 |
|
| 4591 |
1.1 |
|
| 4592 |
1.1 |
|
| 4593 |
1.1 |
|
| 4594 |
1.1 |
|
| 4595 |
1.1 |
|
| 4596 |
1.1 |
|
| 4597 |
1.1 |
|
| 4598 |
1.1 |
|
| 4604 |
1.1 |
|
| 4605 |
1.1 |
|
| 4606 |
1.1 |
|
| 4607 |
1.1 |
|
| 4608 |
1.1 |
|
| 4609 |
1.1 |
|
| 4610 |
1.1 |
|
| 4611 |
1.1 |
|
| 4612 |
1.1 |
|
| 4613 |
1.1 |
|
| 4614 |
1.1 |
|
| 4615 |
1.1 |
|
| 4616 |
1.1 |
|
| 4617 |
1.1 |
|
| 4618 |
1.1 |
|
| 4619 |
1.1 |
|
| 4620 |
1.1 |
|
| 4621 |
1.1 |
|
| 4622 |
1.1 |
|
| 4623 |
1.1 |
|
| 4624 |
1.1 |
|
| 4625 |
1.1 |
|
| 4626 |
1.1 |
|
| 4627 |
1.1 |
|
| 4628 |
1.1 |
|
| 4629 |
1.1 |
|
| 4630 |
1.1 |
|
| 4631 |
1.1 |
|
| 4632 |
1.1 |
|
| 4633 |
1.1 |
|
| 4634 |
1.1 |
|
| 4635 |
1.1 |
|
| 4636 |
1.1 |
|
| 4637 |
1.1 |
|
| 4638 |
1.1 |
|
| 4639 |
1.1 |
|
| 4640 |
1.1 |
|
| 4641 |
1.1 |
|
| 4642 |
1.1 |
|
| 4643 |
1.1 |
|
| 4644 |
1.1 |
|
| 4645 |
1.1 |
|
| 4646 |
1.1 |
|
| 4647 |
1.1 |
|
| 4648 |
1.1 |
|
| 4649 |
1.1 |
|
| 4650 |
1.1 |
|
| 4651 |
1.1 |
|
| 4652 |
1.1 |
|
| 4653 |
1.1 |
|
| 4654 |
1.1 |
|
| 4655 |
1.1 |
|
| 4656 |
1.1 |
|
| 4657 |
1.1 |
|
| 4658 |
1.1 |
|
| 4659 |
1.1 |
|
| 4660 |
1.1 |
|
| 4661 |
1.1 |
|
| 4662 |
1.1 |
|
| 4663 |
1.1 |
|
| 4669 |
1.1 |
|
| 4670 |
1.1 |
|
| 4671 |
1.1 |
|
| 4672 |
1.1 |
|
| 4673 |
1.1 |
|
| 4674 |
1.1 |
|
| 4675 |
1.1 |
|
| 4676 |
1.1 |
|
| 4677 |
1.1 |
|
| 4678 |
1.1 |
|
| 4679 |
1.1 |
|
| 4680 |
1.1 |
|
| 4681 |
1.1 |
|
| 4682 |
1.1 |
|
| 4683 |
1.1 |
|
| 4684 |
1.1 |
|
| 4690 |
1.1 |
|
| 4691 |
1.1 |
|
| 4692 |
1.1 |
|
| 4693 |
1.1 |
|
| 4694 |
1.1 |
|
| 4695 |
1.1 |
|
| 4696 |
1.1 |
|
| 4697 |
1.1 |
|
| 4698 |
1.1 |
|
| 4699 |
1.1 |
|
| 4700 |
1.1 |
|
| 4701 |
1.1 |
|
| 4702 |
1.1 |
|
| 4703 |
1.1 |
|
| 4704 |
1.1 |
|
| 4705 |
1.1 |
|
| 4706 |
1.1 |
|
| 4707 |
1.1 |
|
| 4708 |
1.1 |
|
| 4709 |
1.1 |
|
| 4710 |
1.1 |
|
| 4711 |
1.1 |
|
| 4712 |
1.1 |
|
| 4713 |
1.1 |
|
| 4714 |
1.1 |
|
| 4715 |
1.1 |
|
| 4716 |
1.1 |
|
| 4717 |
1.1 |
|
| 4725 |
1.1 |
|
| 4726 |
1.1 |
|
| 4728 |
1.1 |
|
| 4729 |
1.1 |
|
| 4730 |
1.1 |
|
| 4731 |
1.1 |
|
| 4732 |
1.1 |
|
| 4733 |
1.1 |
|
| 4734 |
1.1 2.2 3.3 |
|
| 4735 |
1.1 |
|
| 4736 |
1.1 2.2 3.3 |
|
| 4737 |
1.1 |
|
| 4738 |
1.1 2.2 3.3 |
|
| 4739 |
1.1 |
|
| 4740 |
1.1 2.2 3.3 |
|
| 4741 |
1.1 |
|
| 4742 |
1.1 2.2 |
|
| 4743 |
1.1 |
|
| 4744 |
1.1 2.2 |
|
| 4745 |
1.1 |
|
| 4746 |
1.1 2.2 |
|
| 4747 |
1.1 |
|
| 4748 |
1.1 2.2 |
|
| 4749 |
1.1 |
|
| 4750 |
1.1 |
|
| 4751 |
1.1 |
|
| 4757 |
1.1 2.2 3.3 |
|
| 4758 |
1.1 |
|
| 4759 |
1.1 |
|
| 4760 |
1.1 2.2 |
|
| 4761 |
1.1 2.2 3.3 |
|
| 4762 |
1.1 2.2 3.3 |
|
| 4763 |
1.1 2.2 3.3 |
|
| 4765 |
1.1 |
|
| 4766 |
1.1 |
|
| 4767 |
1.1 |
|
| 4768 |
1.1 |
|
| 4769 |
1.1 |
|
| 4770 |
1.1 |
|
| 4771 |
1.1 |
|
| 4772 |
1.1 |
|
| 4773 |
1.1 |
|
| 4774 |
1.1 |
|
| 4775 |
1.1 |
|
| 4776 |
1.1 2.2 3.3 |
|
| 4777 |
1.1 |
|
| 4778 |
1.1 2.2 3.3 |
|
| 4779 |
1.1 2.2 3.3 |
|
| 4780 |
1.1 2.2 3.3 |
|
| 4781 |
1.1 2.2 3.3 |
|
| 4782 |
1.1 2.2 3.3 |
|
| 4783 |
1.1 |
|
| 4784 |
1.1 2.2 3.3 |
|
| 4785 |
1.1 |
|
| 4786 |
1.1 2.2 3.3 |
|
| 4787 |
1.1 2.2 3.3 |
|
| 4788 |
1.1 2.2 3.3 |
|
| 4789 |
1.1 2.2 3.3 |
|
| 4790 |
1.1 2.2 3.3 |
|
| 4791 |
1.1 |
|
| 4792 |
1.1 2.2 |
|
| 4793 |
1.1 2.2 |
|
| 4794 |
1.1 2.2 |
|
| 4795 |
1.1 |
|
| 4796 |
1.1 2.2 |
|
| 4797 |
1.1 2.2 |
|
| 4798 |
1.1 2.2 |
|
| 4799 |
1.1 |
|
| 4800 |
1.1 |
|
| 4801 |
1.1 2.2 3.3 |
|
| 4802 |
1.1 2.2 3.3 4.4 |
|
| 4803 |
1.1 |
|
| 4804 |
1.1 |
|
| 4805 |
1.1 2.2 3.3 4.4 |
|
| 4806 |
1.1 2.2 3.3 4.4 |
|
| 4807 |
1.1 |
|
| 4808 |
1.1 |
|
| 4809 |
1.1 2.2 3.3 |
|
| 4810 |
1.1 2.2 3.3 4.4 |
|
| 4811 |
1.1 |
|
| 4812 |
1.1 |
|
| 4813 |
1.1 2.2 3.3 4.4 |
|
| 4814 |
1.1 2.2 3.3 4.4 |
|
| 4815 |
1.1 |
|
| 4816 |
1.1 |
|
| 4817 |
1.1 |
|
| 4818 |
1.1 |
|
| 4819 |
1.1 |
|
| 4820 |
1.1 |
|
| 4821 |
1.1 |
|
| 4822 |
1.1 |
|
| 4823 |
1.1 |
|
| 4824 |
1.1 2.2 3.3 |
|
| 4825 |
1.1 |
|
| 4826 |
1.1 2.2 3.3 |
|
| 4827 |
1.1 2.2 3.3 |
|
| 4828 |
1.1 2.2 3.3 |
|
| 4829 |
1.1 2.2 3.3 |
|
| 4830 |
1.1 2.2 3.3 |
|
| 4831 |
1.1 |
|
| 4832 |
1.1 2.2 3.3 |
|
| 4833 |
1.1 |
|
| 4834 |
1.1 2.2 3.3 |
|
| 4835 |
1.1 2.2 3.3 |
|
| 4836 |
1.1 2.2 3.3 |
|
| 4837 |
1.1 2.2 3.3 |
|
| 4838 |
1.1 2.2 3.3 |
|
| 4839 |
1.1 |
|
| 4840 |
1.1 2.2 |
|
| 4841 |
1.1 2.2 |
|
| 4842 |
1.1 2.2 |
|
| 4843 |
1.1 |
|
| 4844 |
1.1 2.2 |
|
| 4845 |
1.1 2.2 |
|
| 4846 |
1.1 2.2 |
|
| 4847 |
1.1 |
|
| 4848 |
1.1 |
|
| 4849 |
1.1 2.2 3.3 |
|
| 4850 |
1.1 2.2 3.3 4.4 |
|
| 4851 |
1.1 |
|
| 4852 |
1.1 |
|
| 4853 |
1.1 2.2 3.3 4.4 |
|
| 4854 |
1.1 2.2 3.3 4.4 |
|
| 4855 |
1.1 |
|
| 4856 |
1.1 |
|
| 4857 |
1.1 2.2 3.3 |
|
| 4858 |
1.1 2.2 3.3 4.4 |
|
| 4859 |
1.1 |
|
| 4860 |
1.1 |
|
| 4861 |
1.1 2.2 3.3 4.4 5.5 |
|
| 4862 |
1.1 2.2 3.3 4.4 5.5 |
|
| 4864 |
1.1 2.2 |
|
| 4865 |
1.1 2.2 |
|
| 4866 |
1.1 2.2 |
|
| 4867 |
1.1 2.2 |
|
| 4869 |
1.1 |
|
| 4870 |
1.1 |
|
| 4871 |
1.1 |
|
| 4872 |
1.1 |
|
| 4873 |
1.1 |
|
| 4874 |
1.1 |
|
| 4875 |
1.1 |
|
| 4876 |
1.1 2.2 3.3 |
|
| 4877 |
1.1 2.2 3.3 |
|
| 4878 |
1.1 2.2 3.3 |
|
| 4879 |
1.1 2.2 3.3 |
|
| 4880 |
1.1 2.2 3.3 |
|
| 4881 |
1.1 2.2 3.3 |
|
| 4882 |
1.1 2.2 3.3 |
|
| 4883 |
1.1 2.2 3.3 |
|
| 4884 |
1.1 2.2 |
|
| 4885 |
1.1 2.2 |
|
| 4886 |
1.1 2.2 |
|
| 4887 |
1.1 2.2 |
|
| 4888 |
1.1 |
|
| 4889 |
1.1 |
|
| 4890 |
1.1 2.2 3.3 4.4 |
|
| 4891 |
1.1 2.2 3.3 4.4 |
|
| 4892 |
1.1 |
|
| 4893 |
1.1 |
|
| 4894 |
1.1 2.2 3.3 4.4 |
|
| 4895 |
1.1 2.2 3.3 4.4 |
|
| 4896 |
1.1 |
|
| 4897 |
1.1 2.2 3.3 |
|
| 4898 |
1.1 |
|
| 4899 |
1.1 2.2 3.3 |
|
| 4900 |
1.1 |
|
| 4901 |
1.1 2.2 3.3 |
|
| 4902 |
1.1 |
|
| 4903 |
1.1 2.2 3.3 |
|
| 4904 |
1.1 |
|
| 4905 |
1.1 2.2 |
|
| 4906 |
1.1 |
|
| 4907 |
1.1 2.2 |
|
| 4908 |
1.1 |
|
| 4909 |
1.1 |
|
| 4910 |
1.1 2.2 |
|
| 4911 |
1.1 2.2 3.3 |
|
| 4912 |
1.1 |
|
| 4913 |
1.1 |
|
| 4914 |
1.1 2.2 3.3 |
|
| 4915 |
1.1 2.2 3.3 4.4 |
|
| 4916 |
1.1 2.2 3.3 |
|
| 4917 |
1.1 2.2 3.3 |
|
| 4918 |
1.1 2.2 3.3 |
|
| 4919 |
1.1 2.2 3.3 |
|
| 4920 |
1.1 2.2 3.3 |
|
| 4921 |
1.1 2.2 3.3 |
|
| 4922 |
1.1 2.2 3.3 |
|
| 4923 |
1.1 2.2 3.3 |
|
| 4924 |
1.1 2.2 |
|
| 4925 |
1.1 2.2 |
|
| 4926 |
1.1 2.2 |
|
| 4927 |
1.1 2.2 |
|
| 4928 |
1.1 |
|
| 4929 |
1.1 |
|
| 4930 |
1.1 2.2 3.3 4.4 |
|
| 4931 |
1.1 2.2 3.3 4.4 |
|
| 4932 |
1.1 |
|
| 4933 |
1.1 |
|
| 4934 |
1.1 2.2 3.3 4.4 |
|
| 4935 |
1.1 2.2 3.3 4.4 |
|
| 4943 |
1.1 |
|
| 4944 |
1.1 |
|
| 4946 |
1.1 |
|
| 4947 |
1.1 |
|
| 4948 |
1.1 |
|
| 4949 |
1.1 |
|
| 4950 |
1.1 |
|
| 4952 |
1.1 |
|
| 4953 |
1.1 2.2 3.3 4.4 |
|
| 4954 |
1.1 |
|
| 4955 |
1.1 2.2 3.3 4.4 |
|
| 4956 |
1.1 |
|
| 4957 |
1.1 2.2 3.3 |
|
| 4958 |
1.1 |
|
| 4959 |
1.1 2.2 3.3 |
|
| 4960 |
1.1 |
|
| 4961 |
1.1 2.2 |
|
| 4962 |
1.1 |
|
| 4963 |
1.1 2.2 |
|
| 4964 |
1.1 |
|
| 4965 |
1.1 2.2 |
|
| 4966 |
1.1 |
|
| 4967 |
1.1 2.2 |
|
| 4968 |
1.1 |
|
| 4969 |
1.1 |
|
| 4970 |
1.1 |
|
| 4976 |
1.1 2.2 3.3 |
|
| 4977 |
1.1 |
|
| 4978 |
1.1 |
|
| 4979 |
1.1 2.2 |
|
| 4980 |
1.1 2.2 3.3 |
|
| 4981 |
1.1 2.2 3.3 |
|
| 4982 |
1.1 2.2 3.3 |
|
| 4984 |
1.1 |
|
| 4985 |
1.1 |
|
| 4986 |
1.1 |
|
| 4987 |
1.1 |
|
| 4988 |
1.1 |
|
| 4989 |
1.1 |
|
| 4990 |
1.1 |
|
| 4991 |
1.1 |
|
| 4992 |
1.1 |
|
| 4993 |
1.1 |
|
| 4994 |
1.1 |
|
| 4995 |
1.1 2.2 3.3 4.4 |
|
| 4996 |
1.1 2.2 |
|
| 4997 |
1.1 2.2 3.3 4.4 |
|
| 4998 |
1.1 2.2 3.3 |
|
| 4999 |
1.1 2.2 3.3 4.4 |
|
| 5000 |
1.1 2.2 3.3 |
|
| 5001 |
1.1 2.2 3.3 4.4 |
|
| 5002 |
1.1 |
|
| 5003 |
1.1 2.2 3.3 |
|
| 5004 |
1.1 |
|
| 5005 |
1.1 2.2 3.3 |
|
| 5006 |
1.1 2.2 3.3 |
|
| 5007 |
1.1 2.2 3.3 |
|
| 5008 |
1.1 2.2 3.3 |
|
| 5009 |
1.1 2.2 3.3 |
|
| 5010 |
1.1 |
|
| 5011 |
1.1 2.2 |
|
| 5012 |
1.1 2.2 |
|
| 5013 |
1.1 2.2 |
|
| 5014 |
1.1 |
|
| 5015 |
1.1 2.2 |
|
| 5016 |
1.1 2.2 |
|
| 5017 |
1.1 2.2 |
|
| 5018 |
1.1 |
|
| 5019 |
1.1 |
|
| 5020 |
1.1 2.2 3.3 |
|
| 5021 |
1.1 2.2 3.3 4.4 |
|
| 5022 |
1.1 |
|
| 5023 |
1.1 |
|
| 5024 |
1.1 2.2 3.3 4.4 |
|
| 5025 |
1.1 2.2 3.3 4.4 |
|
| 5026 |
1.1 |
|
| 5027 |
1.1 |
|
| 5028 |
1.1 2.2 3.3 |
|
| 5029 |
1.1 2.2 3.3 4.4 |
|
| 5030 |
1.1 |
|
| 5031 |
1.1 |
|
| 5032 |
1.1 2.2 3.3 4.4 |
|
| 5033 |
1.1 2.2 3.3 4.4 |
|
| 5034 |
1.1 |
|
| 5035 |
1.1 |
|
| 5036 |
1.1 |
|
| 5037 |
1.1 |
|
| 5038 |
1.1 |
|
| 5039 |
1.1 |
|
| 5040 |
1.1 |
|
| 5041 |
1.1 |
|
| 5042 |
1.1 |
|
| 5043 |
1.1 2.2 3.3 4.4 |
|
| 5044 |
1.1 |
|
| 5045 |
1.1 2.2 3.3 4.4 |
|
| 5046 |
1.1 2.2 3.3 |
|
| 5047 |
1.1 2.2 3.3 4.4 |
|
| 5048 |
1.1 2.2 3.3 |
|
| 5049 |
1.1 2.2 3.3 4.4 |
|
| 5050 |
1.1 |
|
| 5051 |
1.1 2.2 3.3 |
|
| 5052 |
1.1 |
|
| 5053 |
1.1 2.2 3.3 |
|
| 5054 |
1.1 2.2 3.3 |
|
| 5055 |
1.1 2.2 3.3 |
|
| 5056 |
1.1 2.2 3.3 |
|
| 5057 |
1.1 2.2 3.3 |
|
| 5058 |
1.1 |
|
| 5059 |
1.1 2.2 |
|
| 5060 |
1.1 2.2 |
|
| 5061 |
1.1 2.2 |
|
| 5062 |
1.1 |
|
| 5063 |
1.1 2.2 |
|
| 5064 |
1.1 2.2 |
|
| 5065 |
1.1 2.2 |
|
| 5066 |
1.1 |
|
| 5067 |
1.1 |
|
| 5068 |
1.1 2.2 3.3 |
|
| 5069 |
1.1 2.2 3.3 4.4 |
|
| 5070 |
1.1 |
|
| 5071 |
1.1 |
|
| 5072 |
1.1 2.2 3.3 4.4 |
|
| 5073 |
1.1 2.2 3.3 4.4 |
|
| 5074 |
1.1 |
|
| 5075 |
1.1 |
|
| 5076 |
1.1 2.2 3.3 |
|
| 5077 |
1.1 2.2 3.3 4.4 |
|
| 5078 |
1.1 |
|
| 5079 |
1.1 |
|
| 5080 |
1.1 2.2 3.3 4.4 |
|
| 5081 |
1.1 2.2 3.3 4.4 |
|
| 5083 |
1.1 2.2 |
|
| 5084 |
1.1 2.2 |
|
| 5085 |
1.1 2.2 |
|
| 5086 |
1.1 2.2 |
|
| 5088 |
1.1 |
|
| 5089 |
1.1 |
|
| 5090 |
1.1 |
|
| 5091 |
1.1 |
|
| 5092 |
1.1 |
|
| 5093 |
1.1 |
|
| 5094 |
1.1 |
|
| 5095 |
1.1 2.2 3.3 |
|
| 5096 |
1.1 2.2 3.3 4.4 |
|
| 5097 |
1.1 2.2 3.3 |
|
| 5098 |
1.1 2.2 3.3 4.4 |
|
| 5099 |
1.1 2.2 3.3 |
|
| 5100 |
1.1 2.2 3.3 |
|
| 5101 |
1.1 2.2 3.3 |
|
| 5102 |
1.1 2.2 3.3 |
|
| 5103 |
1.1 2.2 |
|
| 5104 |
1.1 2.2 |
|
| 5105 |
1.1 2.2 |
|
| 5106 |
1.1 2.2 |
|
| 5107 |
1.1 |
|
| 5108 |
1.1 |
|
| 5109 |
1.1 2.2 3.3 4.4 |
|
| 5110 |
1.1 2.2 3.3 4.4 |
|
| 5111 |
1.1 |
|
| 5112 |
1.1 |
|
| 5113 |
1.1 2.2 3.3 4.4 |
|
| 5114 |
1.1 2.2 3.3 4.4 |
|
| 5115 |
1.1 |
|
| 5116 |
1.1 2.2 3.3 4.4 |
|
| 5117 |
1.1 |
|
| 5118 |
1.1 2.2 3.3 4.4 |
|
| 5119 |
1.1 |
|
| 5120 |
1.1 2.2 3.3 |
|
| 5121 |
1.1 |
|
| 5122 |
1.1 2.2 3.3 |
|
| 5123 |
1.1 |
|
| 5124 |
1.1 2.2 |
|
| 5125 |
1.1 |
|
| 5126 |
1.1 2.2 |
|
| 5127 |
1.1 |
|
| 5128 |
1.1 |
|
| 5129 |
1.1 2.2 |
|
| 5130 |
1.1 2.2 3.3 |
|
| 5131 |
1.1 |
|
| 5132 |
1.1 |
|
| 5133 |
1.1 2.2 3.3 |
|
| 5134 |
1.1 2.2 3.3 4.4 |
|
| 5135 |
1.1 2.2 3.3 |
|
| 5136 |
1.1 2.2 3.3 4.4 |
|
| 5137 |
1.1 2.2 3.3 |
|
| 5138 |
1.1 2.2 3.3 4.4 |
|
| 5139 |
1.1 2.2 3.3 |
|
| 5140 |
1.1 2.2 3.3 |
|
| 5141 |
1.1 2.2 3.3 |
|
| 5142 |
1.1 2.2 3.3 |
|
| 5143 |
1.1 2.2 |
|
| 5144 |
1.1 2.2 |
|
| 5145 |
1.1 2.2 |
|
| 5146 |
1.1 2.2 |
|
| 5147 |
1.1 |
|
| 5148 |
1.1 |
|
| 5149 |
1.1 2.2 3.3 4.4 |
|
| 5150 |
1.1 2.2 3.3 4.4 |
|
| 5151 |
1.1 |
|
| 5152 |
1.1 |
|
| 5153 |
1.1 2.2 3.3 4.4 |
|
| 5154 |
1.1 2.2 3.3 4.4 |
|
| 5161 |
1.1 |
|
| 5162 |
1.1 2.2 |
|
| 5163 |
1.1 |
|
| 5164 |
1.1 2.2 3.3 4.4 |
|
| 5166 |
1.1 2.2 |
|
| 5168 |
1.1 |
|
| 5169 |
1.1 2.2 3.3 4.4 |
|
| 5170 |
1.1 |
|
| 5172 |
1.1 2.2 |
|
| 5178 |
1.1 |
|
| 5179 |
1.1 2.2 |
|
| 5180 |
1.1 |
|
| 5181 |
1.1 |
|
| 5182 |
1.1 2.2 3.3 4.4 |
|
| 5184 |
1.1 2.2 3.3 |
|
| 5188 |
1.1 2.2 3.3 |
|
| 5189 |
1.1 |
|
| 5191 |
1.1 |
|
| 5192 |
1.1 |
|
| 5193 |
1.1 |
|
| 5194 |
1.1 2.2 |
|
| 5195 |
1.1 2.2 3.3 4.4 |
|
| 5196 |
1.1 |
|
| 5199 |
1.1 2.2 |
|
| 5200 |
1.1 2.2 3.3 |
|
| 5201 |
1.1 |
|
| 5205 |
1.1 |
|
| 5209 |
1.1 |
|
| 5210 |
1.1 2.2 |
|
| 5211 |
1.1 2.2 |
|
| 5212 |
1.1 2.2 3.3 |
|
| 5213 |
1.1 2.2 3.3 |
|
| 5214 |
1.1 2.2 3.3 |
|
| 5215 |
1.1 2.2 3.3 |
|
| 5216 |
1.1 2.2 3.3 |
|
| 5217 |
1.1 2.2 3.3 |
|
| 5218 |
1.1 2.2 3.3 |
|
| 5219 |
1.1 2.2 3.3 |
|
| 5220 |
1.1 2.2 3.3 |
|
| 5221 |
1.1 2.2 3.3 |
|
| 5222 |
1.1 2.2 3.3 |
|
| 5223 |
1.1 2.2 3.3 |
|
| 5224 |
1.1 2.2 3.3 |
|
| 5225 |
1.1 |
|
| 5226 |
1.1 2.2 3.3 |
|
| 5227 |
1.1 2.2 3.3 |
|
| 5229 |
1.1 2.2 3.3 |
|
| 5230 |
1.1 2.2 3.3 |
|
| 5232 |
1.1 2.2 3.3 |
|
| 5233 |
1.1 2.2 3.3 |
|
| 5234 |
1.1 2.2 3.3 |
|
| 5236 |
1.1 2.2 |
|
| 5237 |
1.1 2.2 |
|
| 5238 |
1.1 2.2 3.3 |
|
| 5239 |
1.1 2.2 3.3 |
|
| 5240 |
1.1 2.2 3.3 |
|
| 5241 |
1.1 2.2 3.3 |
|
| 5242 |
1.1 2.2 3.3 |
|
| 5243 |
1.1 2.2 3.3 |
|
| 5244 |
1.1 2.2 3.3 |
|
| 5245 |
1.1 2.2 3.3 |
|
| 5246 |
1.1 2.2 3.3 |
|
| 5247 |
1.1 2.2 3.3 |
|
| 5248 |
1.1 2.2 3.3 |
|
| 5249 |
1.1 2.2 3.3 |
|
| 5250 |
1.1 2.2 3.3 |
|
| 5251 |
1.1 |
|
| 5252 |
1.1 2.2 3.3 |
|
| 5253 |
1.1 2.2 3.3 |
|
| 5255 |
1.1 2.2 3.3 |
|
| 5256 |
1.1 2.2 3.3 |
|
| 5258 |
1.1 2.2 3.3 |
|
| 5259 |
1.1 2.2 3.3 |
|
| 5260 |
1.1 2.2 3.3 |
|
| 5270 |
1.1 |
|
| 5271 |
1.1 |
|
| 5273 |
1.1 |
|
| 5274 |
1.1 |
|
| 5275 |
1.1 |
|
| 5276 |
1.1 |
|
| 5277 |
1.1 |
|
| 5278 |
1.1 |
|
| 5279 |
1.1 2.2 3.3 |
|
| 5280 |
1.1 |
|
| 5281 |
1.1 2.2 3.3 |
|
| 5282 |
1.1 |
|
| 5283 |
1.1 2.2 3.3 |
|
| 5284 |
1.1 |
|
| 5285 |
1.1 2.2 3.3 |
|
| 5286 |
1.1 |
|
| 5287 |
1.1 2.2 |
|
| 5288 |
1.1 |
|
| 5289 |
1.1 2.2 |
|
| 5290 |
1.1 |
|
| 5291 |
1.1 2.2 |
|
| 5292 |
1.1 |
|
| 5293 |
1.1 2.2 |
|
| 5294 |
1.1 |
|
| 5296 |
1.1 2.2 |
|
| 5297 |
1.1 |
|
| 5298 |
1.1 |
|
| 5300 |
1.1 |
|
| 5301 |
1.1 |
|
| 5302 |
1.1 |
|
| 5303 |
1.1 |
|
| 5304 |
1.1 |
|
| 5305 |
1.1 |
|
| 5306 |
1.1 |
|
| 5307 |
1.1 |
|
| 5308 |
1.1 |
|
| 5309 |
1.1 |
|
| 5310 |
1.1 |
|
| 5311 |
1.1 2.2 3.3 |
|
| 5312 |
1.1 |
|
| 5313 |
1.1 2.2 3.3 |
|
| 5314 |
1.1 |
|
| 5315 |
1.1 2.2 3.3 |
|
| 5316 |
1.1 |
|
| 5317 |
1.1 2.2 3.3 |
|
| 5318 |
1.1 |
|
| 5319 |
1.1 2.2 |
|
| 5320 |
1.1 |
|
| 5321 |
1.1 2.2 |
|
| 5322 |
1.1 |
|
| 5323 |
1.1 |
|
| 5324 |
1.1 2.2 3.3 |
|
| 5325 |
1.1 2.2 3.3 4.4 |
|
| 5326 |
1.1 |
|
| 5327 |
1.1 |
|
| 5328 |
1.1 2.2 3.3 |
|
| 5329 |
1.1 2.2 3.3 4.4 |
|
| 5330 |
1.1 |
|
| 5331 |
1.1 |
|
| 5332 |
1.1 |
|
| 5333 |
1.1 |
|
| 5334 |
1.1 |
|
| 5335 |
1.1 |
|
| 5336 |
1.1 |
|
| 5337 |
1.1 |
|
| 5338 |
1.1 |
|
| 5339 |
1.1 2.2 3.3 |
|
| 5340 |
1.1 |
|
| 5341 |
1.1 2.2 3.3 |
|
| 5342 |
1.1 |
|
| 5343 |
1.1 2.2 3.3 |
|
| 5344 |
1.1 |
|
| 5345 |
1.1 2.2 3.3 |
|
| 5346 |
1.1 |
|
| 5347 |
1.1 2.2 |
|
| 5348 |
1.1 |
|
| 5349 |
1.1 2.2 |
|
| 5350 |
1.1 |
|
| 5351 |
1.1 |
|
| 5352 |
1.1 2.2 3.3 |
|
| 5353 |
1.1 2.2 3.3 4.4 |
|
| 5354 |
1.1 |
|
| 5355 |
1.1 |
|
| 5356 |
1.1 2.2 3.3 |
|
| 5357 |
1.1 2.2 3.3 4.4 |
|
| 5360 |
1.1 |
|
| 5361 |
1.1 |
|
| 5362 |
1.1 |
|
| 5363 |
1.1 |
|
| 5364 |
1.1 |
|
| 5365 |
1.1 |
|
| 5366 |
1.1 |
|
| 5367 |
1.1 |
|
| 5368 |
1.1 2.2 3.3 |
|
| 5369 |
1.1 |
|
| 5370 |
1.1 2.2 3.3 |
|
| 5371 |
1.1 |
|
| 5372 |
1.1 2.2 3.3 |
|
| 5373 |
1.1 |
|
| 5374 |
1.1 2.2 3.3 |
|
| 5375 |
1.1 |
|
| 5376 |
1.1 2.2 |
|
| 5377 |
1.1 |
|
| 5378 |
1.1 2.2 |
|
| 5379 |
1.1 |
|
| 5380 |
1.1 |
|
| 5381 |
1.1 2.2 |
|
| 5382 |
1.1 2.2 3.3 |
|
| 5383 |
1.1 |
|
| 5384 |
1.1 |
|
| 5385 |
1.1 2.2 3.3 |
|
| 5386 |
1.1 2.2 3.3 4.4 |
|
| 5395 |
1.1 |
|
| 5396 |
1.1 |
|
| 5397 |
1.1 |
|
| 5399 |
1.1 |
|
| 5400 |
1.1 |
|
| 5401 |
1.1 |
|
| 5402 |
1.1 |
|
| 5403 |
1.1 |
|
| 5404 |
1.1 2.2 |
|
| 5405 |
1.1 2.2 |
|
| 5406 |
1.1 2.2 |
|
| 5407 |
1.1 2.2 |
|
| 5408 |
1.1 2.2 |
|
| 5409 |
1.1 2.2 |
|
| 5410 |
1.1 2.2 |
|
| 5411 |
1.1 2.2 |
|
| 5412 |
1.1 2.2 |
|
| 5413 |
1.1 2.2 |
|
| 5414 |
1.1 |
|
| 5415 |
1.1 2.2 |
|
| 5416 |
1.1 |
|
| 5417 |
1.1 2.2 |
|
| 5418 |
1.1 2.2 |
|
| 5419 |
1.1 2.2 |
|
| 5420 |
1.1 |
|
| 5421 |
1.1 2.2 |
|
| 5422 |
1.1 |
|
| 5423 |
1.1 2.2 |
|
| 5425 |
1.1 |
|
| 5426 |
1.1 2.2 |
|
| 5427 |
1.1 |
|
| 5428 |
1.1 |
|
| 5430 |
1.1 |
|
| 5431 |
1.1 |
|
| 5432 |
1.1 |
|
| 5433 |
1.1 |
|
| 5434 |
1.1 |
|
| 5436 |
1.1 |
|
| 5437 |
1.1 |
|
| 5438 |
1.1 |
|
| 5439 |
1.1 |
|
| 5440 |
1.1 |
|
| 5441 |
1.1 |
|
| 5442 |
1.1 |
|
| 5443 |
1.1 |
|
| 5444 |
1.1 |
|
| 5445 |
1.1 |
|
| 5446 |
1.1 2.2 |
|
| 5447 |
1.1 2.2 |
|
| 5448 |
1.1 2.2 |
|
| 5449 |
1.1 2.2 |
|
| 5450 |
1.1 2.2 |
|
| 5451 |
1.1 2.2 |
|
| 5452 |
1.1 2.2 |
|
| 5453 |
1.1 2.2 |
|
| 5454 |
1.1 2.2 3.3 |
|
| 5455 |
1.1 2.2 3.3 |
|
| 5456 |
1.1 2.2 3.3 |
|
| 5457 |
1.1 2.2 3.3 |
|
| 5458 |
1.1 |
|
| 5459 |
1.1 2.2 |
|
| 5460 |
1.1 |
|
| 5461 |
1.1 2.2 |
|
| 5462 |
1.1 2.2 3.3 |
|
| 5463 |
1.1 2.2 3.3 |
|
| 5464 |
1.1 2.2 3.3 |
|
| 5465 |
1.1 2.2 3.3 |
|
| 5466 |
1.1 |
|
| 5467 |
1.1 2.2 |
|
| 5468 |
1.1 |
|
| 5469 |
1.1 2.2 |
|
| 5470 |
1.1 |
|
| 5471 |
1.1 |
|
| 5472 |
1.1 |
|
| 5473 |
1.1 |
|
| 5474 |
1.1 |
|
| 5475 |
1.1 |
|
| 5476 |
1.1 |
|
| 5477 |
1.1 |
|
| 5478 |
1.1 2.2 |
|
| 5479 |
1.1 2.2 |
|
| 5480 |
1.1 2.2 |
|
| 5481 |
1.1 2.2 |
|
| 5482 |
1.1 2.2 |
|
| 5483 |
1.1 2.2 |
|
| 5484 |
1.1 2.2 |
|
| 5485 |
1.1 2.2 |
|
| 5486 |
1.1 2.2 3.3 |
|
| 5487 |
1.1 2.2 3.3 |
|
| 5488 |
1.1 2.2 3.3 |
|
| 5489 |
1.1 2.2 3.3 |
|
| 5490 |
1.1 |
|
| 5491 |
1.1 2.2 |
|
| 5492 |
1.1 |
|
| 5493 |
1.1 2.2 |
|
| 5494 |
1.1 2.2 3.3 |
|
| 5495 |
1.1 2.2 3.3 |
|
| 5496 |
1.1 2.2 3.3 |
|
| 5497 |
1.1 2.2 3.3 |
|
| 5498 |
1.1 |
|
| 5499 |
1.1 2.2 |
|
| 5500 |
1.1 |
|
| 5501 |
1.1 2.2 |
|
| 5503 |
1.1 |
|
| 5504 |
1.1 2.2 |
|
| 5506 |
1.1 |
|
| 5507 |
1.1 |
|
| 5508 |
1.1 |
|
| 5509 |
1.1 |
|
| 5510 |
1.1 |
|
| 5511 |
1.1 |
|
| 5512 |
1.1 |
|
| 5513 |
1.1 2.2 |
|
| 5514 |
1.1 2.2 |
|
| 5515 |
1.1 2.2 |
|
| 5516 |
1.1 2.2 |
|
| 5517 |
1.1 2.2 |
|
| 5518 |
1.1 2.2 |
|
| 5519 |
1.1 2.2 |
|
| 5520 |
1.1 2.2 |
|
| 5521 |
1.1 2.2 3.3 |
|
| 5522 |
1.1 2.2 3.3 |
|
| 5523 |
1.1 2.2 3.3 |
|
| 5524 |
1.1 2.2 3.3 |
|
| 5525 |
1.1 |
|
| 5526 |
1.1 2.2 |
|
| 5527 |
1.1 |
|
| 5528 |
1.1 2.2 |
|
| 5529 |
1.1 2.2 3.3 |
|
| 5530 |
1.1 2.2 3.3 |
|
| 5531 |
1.1 2.2 3.3 |
|
| 5532 |
1.1 2.2 3.3 |
|
| 5533 |
1.1 |
|
| 5534 |
1.1 2.2 |
|
| 5535 |
1.1 |
|
| 5536 |
1.1 2.2 |
|
| 5540 |
1.1 |
|
| 5541 |
1.1 2.2 |
|
| 5542 |
1.1 2.2 3.3 |
|
| 5543 |
1.1 2.2 3.3 |
|
| 5544 |
1.1 2.2 3.3 |
|
| 5546 |
1.1 2.2 |
|
| 5547 |
1.1 2.2 3.3 |
|
| 5548 |
1.1 2.2 3.3 |
|
| 5549 |
1.1 2.2 3.3 |
|
| 5556 |
1.1 |
|
| 5557 |
1.1 |
|
| 5558 |
1.1 |
|
| 5560 |
1.1 2.2 |
|
| 5561 |
1.1 2.2 3.3 |
|
| 5562 |
1.1 2.2 |
|
| 5563 |
1.1 2.2 3.3 |
|
| 5564 |
1.1 2.2 3.3 |
|
| 5565 |
1.1 2.2 3.3 |
|
| 5566 |
1.1 2.2 3.3 |
|
| 5567 |
1.1 2.2 3.3 |
|
| 5568 |
1.1 |
|
| 5569 |
1.1 |
|
| 5570 |
1.1 |
|
| 5571 |
1.1 |
|
| 5572 |
1.1 |
|
| 5573 |
1.1 |
|
| 5574 |
1.1 |
|
| 5575 |
1.1 |
|
| 5576 |
1.1 2.2 3.3 |
|
| 5577 |
1.1 2.2 3.3 |
|
| 5578 |
1.1 2.2 3.3 |
|
| 5579 |
1.1 2.2 3.3 |
|
| 5580 |
1.1 2.2 3.3 |
|
| 5581 |
1.1 2.2 3.3 |
|
| 5582 |
1.1 2.2 3.3 |
|
| 5583 |
1.1 2.2 3.3 |
|
| 5584 |
1.1 |
|
| 5585 |
1.1 |
|
| 5586 |
1.1 |
|
| 5587 |
1.1 |
|
| 5588 |
1.1 |
|
| 5589 |
1.1 |
|
| 5590 |
1.1 2.2 3.3 |
|
| 5591 |
1.1 2.2 3.3 |
|
| 5592 |
1.1 |
|
| 5593 |
1.1 |
|
| 5594 |
1.1 2.2 3.3 |
|
| 5595 |
1.1 2.2 3.3 |
|
| 5596 |
1.1 2.2 3.3 |
|
| 5597 |
1.1 2.2 3.3 |
|
| 5598 |
1.1 2.2 3.3 |
|
| 5599 |
1.1 2.2 3.3 |
|
| 5600 |
1.1 2.2 3.3 |
|
| 5601 |
1.1 2.2 3.3 |
|
| 5602 |
1.1 2.2 3.3 |
|
| 5603 |
1.1 2.2 3.3 |
|
| 5604 |
1.1 |
|
| 5605 |
1.1 |
|
| 5606 |
1.1 |
|
| 5607 |
1.1 |
|
| 5608 |
1.1 |
|
| 5609 |
1.1 |
|
| 5610 |
1.1 2.2 |
|
| 5611 |
1.1 2.2 |
|
| 5612 |
1.1 |
|
| 5613 |
1.1 |
|
| 5614 |
1.1 2.2 |
|
| 5615 |
1.1 2.2 |
|
| 5616 |
1.1 2.2 3.3 |
|
| 5617 |
1.1 2.2 3.3 |
|
| 5618 |
1.1 2.2 3.3 |
|
| 5619 |
1.1 2.2 3.3 |
|
| 5620 |
1.1 2.2 3.3 |
|
| 5621 |
1.1 2.2 3.3 |
|
| 5622 |
1.1 2.2 3.3 |
|
| 5623 |
1.1 2.2 3.3 |
|
| 5624 |
1.1 |
|
| 5625 |
1.1 |
|
| 5626 |
1.1 |
|
| 5627 |
1.1 |
|
| 5628 |
1.1 |
|
| 5629 |
1.1 |
|
| 5630 |
1.1 2.2 3.3 |
|
| 5631 |
1.1 2.2 3.3 |
|
| 5632 |
1.1 |
|
| 5633 |
1.1 |
|
| 5634 |
1.1 2.2 3.3 |
|
| 5635 |
1.1 2.2 3.3 |
|
| 5636 |
1.1 |
|
| 5637 |
1.1 |
|
| 5638 |
1.1 |
|
| 5639 |
1.1 |
|
| 5640 |
1.1 |
|
| 5641 |
1.1 |
|
| 5642 |
1.1 |
|
| 5643 |
1.1 |
|
| 5644 |
1.1 2.2 |
|
| 5645 |
1.1 2.2 |
|
| 5646 |
1.1 2.2 |
|
| 5647 |
1.1 2.2 |
|
| 5648 |
1.1 2.2 |
|
| 5649 |
1.1 2.2 |
|
| 5650 |
1.1 2.2 |
|
| 5651 |
1.1 2.2 |
|
| 5652 |
1.1 |
|
| 5653 |
1.1 |
|
| 5654 |
1.1 |
|
| 5655 |
1.1 |
|
| 5656 |
1.1 |
|
| 5657 |
1.1 |
|
| 5658 |
1.1 |
|
| 5659 |
1.1 |
|
| 5660 |
1.1 2.2 |
|
| 5661 |
1.1 2.2 |
|
| 5662 |
1.1 2.2 |
|
| 5663 |
1.1 2.2 |
|
| 5664 |
1.1 2.2 |
|
| 5665 |
1.1 2.2 |
|
| 5666 |
1.1 2.2 |
|
| 5667 |
1.1 2.2 |
|
| 5668 |
1.1 |
|
| 5669 |
1.1 |
|
| 5670 |
1.1 2.2 |
|
| 5671 |
1.1 2.2 |
|
| 5672 |
1.1 |
|
| 5673 |
1.1 |
|
| 5674 |
1.1 2.2 |
|
| 5675 |
1.1 2.2 |
|
| 5676 |
1.1 |
|
| 5677 |
1.1 |
|
| 5678 |
1.1 |
|
| 5679 |
1.1 |
|
| 5680 |
1.1 2.2 |
|
| 5681 |
1.1 2.2 |
|
| 5682 |
1.1 2.2 |
|
| 5683 |
1.1 2.2 |
|
| 5684 |
1.1 2.2 |
|
| 5685 |
1.1 2.2 |
|
| 5686 |
1.1 2.2 |
|
| 5687 |
1.1 2.2 |
|
| 5688 |
1.1 |
|
| 5689 |
1.1 |
|
| 5690 |
1.1 |
|
| 5691 |
1.1 |
|
| 5692 |
1.1 |
|
| 5693 |
1.1 |
|
| 5694 |
1.1 |
|
| 5695 |
1.1 |
|
| 5696 |
1.1 |
|
| 5697 |
1.1 2.2 |
|
| 5698 |
1.1 2.2 |
|
| 5699 |
1.1 2.2 |
|
| 5700 |
1.1 2.2 |
|
| 5701 |
1.1 2.2 |
|
| 5702 |
1.1 2.2 |
|
| 5703 |
1.1 2.2 |
|
| 5709 |
1.1 |
|
| 5710 |
1.1 |
|
| 5711 |
1.1 |
|
| 5712 |
1.1 |
|
| 5713 |
1.1 2.2 |
|
| 5714 |
1.1 |
|
| 5715 |
1.1 |
|
| 5716 |
1.1 2.2 |
|
| 5717 |
1.1 2.2 3.3 |
|
| 5718 |
1.1 2.2 3.3 |
|
| 5719 |
1.1 2.2 3.3 |
|
| 5720 |
1.1 2.2 |
|
| 5721 |
1.1 2.2 |
|
| 5722 |
1.1 |
|
| 5723 |
1.1 |
|
| 5724 |
1.1 |
|
| 5725 |
1.1 |
|
| 5726 |
1.1 2.2 |
|
| 5727 |
1.1 2.2 3.3 |
|
| 5728 |
1.1 2.2 3.3 |
|
| 5729 |
1.1 2.2 3.3 |
|
| 5730 |
1.1 2.2 |
|
| 5731 |
1.1 2.2 |
|
| 5732 |
1.1 |
|
| 5733 |
1.1 |
|
| 5734 |
1.1 |
|
| 5735 |
1.1 |
|
| 5736 |
1.1 2.2 3.3 |
|
| 5737 |
1.1 2.2 3.3 |
|
| 5738 |
1.1 2.2 3.3 |
|
| 5739 |
1.1 2.2 3.3 |
|
| 5740 |
1.1 2.2 3.3 |
|
| 5741 |
1.1 2.2 3.3 |
|
| 5742 |
1.1 2.2 3.3 |
|
| 5743 |
1.1 2.2 3.3 |
|
| 5744 |
1.1 |
|
| 5745 |
1.1 |
|
| 5746 |
1.1 |
|
| 5747 |
1.1 |
|
| 5748 |
1.1 2.2 3.3 |
|
| 5749 |
1.1 2.2 3.3 |
|
| 5750 |
1.1 2.2 3.3 |
|
| 5751 |
1.1 2.2 3.3 |
|
| 5752 |
1.1 2.2 3.3 |
|
| 5753 |
1.1 2.2 3.3 |
|
| 5754 |
1.1 2.2 3.3 |
|
| 5755 |
1.1 2.2 3.3 |
|
| 5756 |
1.1 |
|
| 5757 |
1.1 |
|
| 5758 |
1.1 |
|
| 5759 |
1.1 |
|
| 5760 |
1.1 2.2 3.3 |
|
| 5761 |
1.1 2.2 3.3 |
|
| 5762 |
1.1 2.2 3.3 |
|
| 5763 |
1.1 2.2 3.3 |
|
| 5764 |
1.1 2.2 3.3 |
|
| 5765 |
1.1 2.2 3.3 |
|
| 5766 |
1.1 2.2 3.3 |
|
| 5767 |
1.1 2.2 3.3 |
|
| 5768 |
1.1 |
|
| 5769 |
1.1 |
|
| 5770 |
1.1 |
|
| 5771 |
1.1 |
|
| 5772 |
1.1 2.2 3.3 |
|
| 5773 |
1.1 2.2 3.3 |
|
| 5774 |
1.1 2.2 3.3 |
|
| 5775 |
1.1 2.2 3.3 |
|
| 5776 |
1.1 2.2 3.3 |
|
| 5777 |
1.1 2.2 3.3 |
|
| 5778 |
1.1 2.2 3.3 |
|
| 5779 |
1.1 2.2 3.3 |
|
| 5780 |
1.1 |
|
| 5781 |
1.1 |
|
| 5782 |
1.1 |
|
| 5783 |
1.1 |
|
| 5784 |
1.1 2.2 3.3 |
|
| 5785 |
1.1 2.2 3.3 |
|
| 5786 |
1.1 2.2 3.3 |
|
| 5787 |
1.1 2.2 3.3 |
|
| 5788 |
1.1 2.2 3.3 |
|
| 5789 |
1.1 2.2 3.3 |
|
| 5790 |
1.1 2.2 3.3 |
|
| 5791 |
1.1 2.2 3.3 |
|
| 5792 |
1.1 |
|
| 5793 |
1.1 |
|
| 5794 |
1.1 |
|
| 5795 |
1.1 |
|
| 5796 |
1.1 2.2 3.3 |
|
| 5797 |
1.1 2.2 3.3 |
|
| 5798 |
1.1 2.2 3.3 |
|
| 5799 |
1.1 2.2 3.3 |
|
| 5800 |
1.1 2.2 3.3 |
|
| 5801 |
1.1 2.2 3.3 |
|
| 5802 |
1.1 2.2 3.3 |
|
| 5803 |
1.1 2.2 3.3 |
|
| 5804 |
1.1 |
|
| 5805 |
1.1 |
|
| 5806 |
1.1 |
|
| 5807 |
1.1 |
|
| 5808 |
1.1 |
|
| 5809 |
1.1 |
|
| 5810 |
1.1 |
|
| 5811 |
1.1 |
|
| 5812 |
1.1 |
|
| 5813 |
1.1 2.2 |
|
| 5814 |
1.1 2.2 |
|
| 5815 |
1.1 2.2 |
|
| 5816 |
1.1 |
|
| 5817 |
1.1 |
|
| 5818 |
1.1 |
|
| 5819 |
1.1 |
|
| 5820 |
1.1 2.2 |
|
| 5821 |
1.1 2.2 |
|
| 5822 |
1.1 2.2 |
|
| 5823 |
1.1 2.2 |
|
| 5824 |
1.1 |
|
| 5825 |
1.1 |
|
| 5826 |
1.1 |
|
| 5827 |
1.1 |
|
| 5828 |
1.1 2.2 |
|
| 5829 |
1.1 2.2 |
|
| 5830 |
1.1 2.2 |
|
| 5831 |
1.1 2.2 |
|
| 5832 |
1.1 2.2 |
|
| 5833 |
1.1 2.2 |
|
| 5834 |
1.1 |
|
| 5835 |
1.1 |
|
| 5836 |
1.1 |
|
| 5837 |
1.1 |
|
| 5838 |
1.1 2.2 |
|
| 5839 |
1.1 2.2 |
|
| 5840 |
1.1 2.2 |
|
| 5841 |
1.1 2.2 |
|
| 5842 |
1.1 2.2 |
|
| 5843 |
1.1 2.2 |
|
| 5844 |
1.1 |
|
| 5845 |
1.1 |
|
| 5846 |
1.1 |
|
| 5847 |
1.1 |
|
| 5848 |
1.1 2.2 |
|
| 5849 |
1.1 2.2 |
|
| 5850 |
1.1 2.2 |
|
| 5851 |
1.1 2.2 |
|
| 5852 |
1.1 |
|
| 5853 |
1.1 |
|
| 5854 |
1.1 |
|
| 5855 |
1.1 |
|
| 5856 |
1.1 2.2 |
|
| 5857 |
1.1 2.2 |
|
| 5858 |
1.1 2.2 |
|
| 5859 |
1.1 2.2 |
|
| 5860 |
1.1 |
|
| 5861 |
1.1 |
|
| 5862 |
1.1 |
|
| 5863 |
1.1 |
|
| 5864 |
1.1 2.2 |
|
| 5865 |
1.1 2.2 |
|
| 5866 |
1.1 2.2 |
|
| 5867 |
1.1 2.2 |
|
| 5868 |
1.1 2.2 |
|
| 5869 |
1.1 2.2 |
|
| 5870 |
1.1 |
|
| 5871 |
1.1 |
|
| 5872 |
1.1 |
|
| 5873 |
1.1 |
|
| 5874 |
1.1 2.2 |
|
| 5875 |
1.1 2.2 |
|
| 5876 |
1.1 2.2 |
|
| 5877 |
1.1 2.2 |
|
| 5878 |
1.1 2.2 |
|
| 5879 |
1.1 2.2 |
|
| 5885 |
1.1 |
|
| 5886 |
1.1 2.2 |
|
| 5887 |
1.1 2.2 3.3 |
|
| 5888 |
1.1 2.2 |
|
| 5889 |
1.1 2.2 3.3 |
|
| 5890 |
1.1 2.2 3.3 |
|
| 5891 |
1.1 2.2 3.3 |
|
| 5892 |
1.1 2.2 3.3 |
|
| 5893 |
1.1 2.2 3.3 |
|
| 5894 |
1.1 |
|
| 5895 |
1.1 |
|
| 5896 |
1.1 |
|
| 5897 |
1.1 |
|
| 5898 |
1.1 |
|
| 5899 |
1.1 |
|
| 5900 |
1.1 |
|
| 5901 |
1.1 |
|
| 5902 |
1.1 2.2 3.3 |
|
| 5903 |
1.1 2.2 3.3 |
|
| 5904 |
1.1 2.2 3.3 |
|
| 5905 |
1.1 2.2 3.3 |
|
| 5906 |
1.1 2.2 3.3 |
|
| 5907 |
1.1 2.2 3.3 |
|
| 5908 |
1.1 2.2 3.3 |
|
| 5909 |
1.1 2.2 3.3 |
|
| 5910 |
1.1 |
|
| 5911 |
1.1 |
|
| 5912 |
1.1 |
|
| 5913 |
1.1 |
|
| 5914 |
1.1 |
|
| 5915 |
1.1 |
|
| 5916 |
1.1 |
|
| 5917 |
1.1 |
|
| 5918 |
1.1 2.2 |
|
| 5919 |
1.1 2.2 |
|
| 5920 |
1.1 2.2 |
|
| 5921 |
1.1 2.2 |
|
| 5922 |
1.1 2.2 |
|
| 5923 |
1.1 2.2 |
|
| 5924 |
1.1 2.2 |
|
| 5925 |
1.1 2.2 |
|
| 5926 |
1.1 2.2 |
|
| 5927 |
1.1 2.2 |
|
| 5928 |
1.1 2.2 |
|
| 5929 |
1.1 2.2 |
|
| 5930 |
1.1 |
|
| 5931 |
1.1 2.2 |
|
| 5932 |
1.1 2.2 |
|
| 5933 |
1.1 2.2 |
|
| 5934 |
1.1 2.2 |
|
| 5935 |
1.1 2.2 |
|
| 5936 |
1.1 2.2 |
|
| 5937 |
1.1 2.2 |
|
| 5943 |
1.1 |
|
| 5944 |
1.1 |
|
| 5945 |
1.1 |
|
| 5946 |
1.1 2.2 |
|
| 5947 |
1.1 2.2 3.3 |
|
| 5948 |
1.1 2.2 |
|
| 5949 |
1.1 2.2 3.3 |
|
| 5950 |
1.1 2.2 3.3 |
|
| 5951 |
1.1 2.2 3.3 |
|
| 5952 |
1.1 2.2 |
|
| 5953 |
1.1 2.2 |
|
| 5954 |
1.1 2.2 3.3 |
|
| 5955 |
1.1 2.2 3.3 |
|
| 5956 |
1.1 2.2 |
|
| 5957 |
1.1 2.2 |
|
| 5958 |
1.1 2.2 3.3 |
|
| 5959 |
1.1 2.2 3.3 |
|
| 5960 |
1.1 2.2 3.3 |
|
| 5961 |
1.1 2.2 3.3 |
|
| 5962 |
1.1 2.2 3.3 |
|
| 5963 |
1.1 2.2 3.3 |
|
| 5964 |
1.1 2.2 3.3 |
|
| 5965 |
1.1 2.2 3.3 |
|
| 5966 |
1.1 2.2 3.3 |
|
| 5967 |
1.1 2.2 3.3 |
|
| 5968 |
1.1 2.2 3.3 |
|
| 5969 |
1.1 2.2 3.3 |
|
| 5970 |
1.1 2.2 3.3 |
|
| 5971 |
1.1 2.2 3.3 |
|
| 5972 |
1.1 2.2 3.3 |
|
| 5973 |
1.1 2.2 3.3 |
|
| 5974 |
1.1 |
|
| 5975 |
1.1 |
|
| 5976 |
1.1 |
|
| 5977 |
1.1 |
|
| 5978 |
1.1 |
|
| 5979 |
1.1 2.2 |
|
| 5980 |
1.1 2.2 |
|
| 5981 |
1.1 2.2 |
|
| 5982 |
1.1 |
|
| 5983 |
1.1 |
|
| 5984 |
1.1 |
|
| 5985 |
1.1 |
|
| 5986 |
1.1 2.2 |
|
| 5987 |
1.1 2.2 |
|
| 5988 |
1.1 2.2 |
|
| 5989 |
1.1 2.2 |
|
| 5990 |
1.1 |
|
| 5991 |
1.1 |
|
| 5992 |
1.1 |
|
| 5993 |
1.1 |
|
| 5994 |
1.1 2.2 |
|
| 5995 |
1.1 2.2 |
|
| 5996 |
1.1 2.2 |
|
| 5997 |
1.1 2.2 |
|
| 5998 |
1.1 |
|
| 5999 |
1.1 |
|
| 6000 |
1.1 |
|
| 6001 |
1.1 |
|
| 6002 |
1.1 2.2 |
|
| 6003 |
1.1 2.2 |
|
| 6004 |
1.1 2.2 |
|
| 6005 |
1.1 2.2 |
|
| 6011 |
1.1 2.2 |
|
| 6012 |
1.1 2.2 3.3 |
|
| 6013 |
1.1 2.2 |
|
| 6014 |
1.1 2.2 3.3 |
|
| 6015 |
1.1 2.2 3.3 |
|
| 6016 |
1.1 2.2 3.3 |
|
| 6017 |
1.1 2.2 3.3 |
|
| 6018 |
1.1 2.2 3.3 |
|
| 6019 |
1.1 |
|
| 6020 |
1.1 2.2 |
|
| 6021 |
1.1 2.2 |
|
| 6022 |
1.1 2.2 |
|
| 6023 |
1.1 2.2 |
|
| 6024 |
1.1 2.2 |
|
| 6025 |
1.1 2.2 |
|
| 6026 |
1.1 2.2 |
|
| 6032 |
1.1 2.2 |
|
| 6033 |
1.1 2.2 3.3 |
|
| 6034 |
1.1 2.2 |
|
| 6035 |
1.1 2.2 3.3 |
|
| 6036 |
1.1 2.2 3.3 |
|
| 6037 |
1.1 2.2 3.3 |
|
| 6038 |
1.1 2.2 3.3 |
|
| 6039 |
1.1 2.2 3.3 |
|
| 6040 |
1.1 |
|
| 6041 |
1.1 2.2 |
|
| 6042 |
1.1 2.2 |
|
| 6043 |
1.1 2.2 |
|
| 6044 |
1.1 2.2 |
|
| 6045 |
1.1 2.2 |
|
| 6046 |
1.1 2.2 |
|
| 6047 |
1.1 2.2 |
|
| 6052 |
1.1 2.2 |
|
| 6053 |
1.1 2.2 3.3 4.4 |
|
| 6054 |
1.1 2.2 |
|
| 6055 |
1.1 2.2 3.3 |
|
| 6056 |
1.1 |
|
| 6057 |
1.1 |
|
| 6063 |
1.1 2.2 |
|
| 6064 |
1.1 2.2 3.3 |
|
| 6065 |
1.1 2.2 |
|
| 6066 |
1.1 2.2 3.3 |
|
| 6067 |
1.1 |
|
| 6068 |
1.1 |
|
| 6073 |
1.1 2.2 |
|
| 6074 |
1.1 2.2 3.3 |
|
| 6075 |
1.1 2.2 |
|
| 6076 |
1.1 2.2 3.3 |
|
| 6077 |
1.1 |
|
| 6078 |
1.1 |
|
| 6086 |
1.1 |
|
| 6087 |
1.1 2.2 |
|
| 6089 |
1.1 2.2 |
|
| 6090 |
1.1 |
|
| 6091 |
1.1 |
|
| 6092 |
1.1 2.2 3.3 |
|
| 6093 |
1.1 |
|
| 6094 |
1.1 |
|
| 6095 |
1.1 |
|
| 6096 |
1.1 |
|
| 6097 |
1.1 2.2 3.3 |
|
| 6098 |
1.1 2.2 3.3 |
|
| 6099 |
1.1 2.2 3.3 |
|
| 6100 |
1.1 |
|
| 6101 |
1.1 2.2 3.3 |
|
| 6102 |
1.1 |
|
| 6103 |
1.1 2.2 3.3 |
|
| 6105 |
1.1 2.2 3.3 4.4 5.5 |
|
| 6113 |
1.1 |
|
| 6114 |
1.1 2.2 |
|
| 6116 |
1.1 2.2 |
|
| 6117 |
1.1 |
|
| 6118 |
1.1 |
|
| 6119 |
1.1 2.2 3.3 |
|
| 6120 |
1.1 |
|
| 6121 |
1.1 |
|
| 6122 |
1.1 |
|
| 6123 |
1.1 |
|
| 6124 |
1.1 2.2 3.3 |
|
| 6125 |
1.1 2.2 3.3 |
|
| 6126 |
1.1 2.2 3.3 |
|
| 6127 |
1.1 |
|
| 6128 |
1.1 2.2 |
|
| 6129 |
1.1 |
|
| 6130 |
1.1 2.2 |
|
| 6135 |
1.1 |
|
| 6137 |
1.1 |
|
| 6138 |
1.1 |
|
| 6143 |
1.1 2.2 3.3 |
|
| 6144 |
1.1 |